Что ~~ («двойная тильда») делает в Javascript?

Сегодня я проверял библиотеку физики онлайн-игр и наткнулся на оператора ~~. Я знаю, что одно ~ является побитовым НЕ, разве это сделало бы ~~ НЕ НЕ, что вернуло бы то же значение, не так ли?

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

Другими словами, это дает:

function(x) {
  if(x < 0) return Math.ceil(x);
  else return Math.floor(x);
}

только если x находится между - (2 ³¹ ) и 2 ³¹ - 1. В противном случае произойдет переполнение, и число «обернется».

Это может считаться полезным для преобразования строкового аргумента функции в число, но как из-за возможности переполнения, так и из-за того, что оно некорректно для использования с нецелыми числами, я бы не использовал его таким образом, за исключением «кода гольфа» ( т.е. бессмысленно обрезать байты исходного кода вашей программы за счет читабельности и надежности). Я бы использовал +xили Number(x)вместо.

Как это НЕ из НЕ

Число -43.2, например:

-43,2 ₁₀ = 11111111111111111111111111010101 ₂

как 32-разрядное двоичное число со знаком (дополнение к двум). (JavaScript игнорирует то, что находится после десятичной точки.) Инвертирование битов дает:

НЕ -43 ₁₀ = 00000000000000000000000000101010 ₂ = 42 ₁₀

Инвертирование снова дает:

НЕ 42 ₁₀ = 11111111111111111111111111010101 ₂ = -43 ₁₀

Это отличается от того, Math.floor(-43.2)что отрицательные числа округляются до нуля, а не от него. (Функция floor, которая будет равна -44, всегда округляется до следующего более низкого целого числа, независимо от того, является ли число положительным или отрицательным.)

Первый оператор ~ переводит операнд в целое число (возможно, после приведения значения к строке или логическому значению), затем инвертирует младшие 31 бит. Официально все числа ECMAScript представляют собой числа с плавающей точкой, но некоторые числа реализованы как 31-разрядные целые числа в движке SpiderMonkey.

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

Затем второй оператор ~ инвертирует биты обратно, так что вы знаете, что у вас будет целое число. Это не то же самое, что приведение значения к логическому значению в операторе условия, потому что пустой объект {} оценивается как true, тогда как ~~ {} оценивается как false.

js>~~"yes"
0
js>~~3
3
js>~~"yes"
0
js>~~false
0
js>~~""
0
js>~~true
1
js>~~"3"
3
js>~~{}
0
js>~~{a:2}
0
js>~~[2]
2
js>~~[2,3]
0
js>~~{toString: function() {return 4}}
4
js>~~NaN
0
js>~~[4.5]
4
js>~~5.6
5
js>~~-5.6
-5

В ECMAScript 6 эквивалентом ~~является Math.trunc :

Возвращает неотъемлемую часть числа путем удаления любых дробных цифр. Он не округляет никаких чисел.

Math.trunc(13.37)   // 13
Math.trunc(42.84)   // 42
Math.trunc(0.123)   //  0
Math.trunc(-0.123)  // -0
Math.trunc("-1.123")// -1
Math.trunc(NaN)     // NaN
Math.trunc("foo")   // NaN
Math.trunc()        // NaN

Полифилл:

function trunc(x) {
    return x < 0 ? Math.ceil(x) : Math.floor(x);
}

~, Кажется, делает -(N+1). Так что, ~2 == -(2 + 1) == -3если вы сделаете это снова на -3, это вернет его обратно: ~-3 == -(-3 + 1) == 2вероятно, он просто конвертирует строку в число в обратном порядке.

Смотрите эту ветку: http://www.sitepoint.com/forums/showthread.php?t=663275

Также более подробная информация доступна здесь: http://dreaminginjavascript.wordpress.com/2008/07/04/28/

Дано ~Nесть -(N+1), ~~Nесть потом -(-(N+1) + 1). Что, очевидно, приводит к изящному трюку .

Просто предупреждение. Другие ответы привели меня в беду.

Намерение состоит в том, чтобы удалить что-либо после десятичной точки числа с плавающей запятой, но у него есть некоторые угловые случаи, которые делают это ошибкой. Я бы рекомендовал избегать ~~.

Во-первых, ~~ не работает с очень большими числами.

~~1000000000000 == -727279968

В качестве альтернативы используйте Math.trunc()(как упоминал Gajus, Math.trunc()возвращает целую часть числа с плавающей запятой, но доступно только в JavaScript, совместимом с ECMAScript 6). Вы всегда можете сделать свой собственный Math.trunc()для не-ECMAScript-6 сред, выполнив это:

if(!Math.trunc){
    Math.trunc = function(value){
        return Math.sign(value) * Math.floor(Math.abs(value));
    }
}

Я написал сообщение в блоге об этом для справки: http://bitlords.blogspot.com/2016/08/the-double-tilde-x-technique-in.html

Вот пример того, как этот оператор может использоваться эффективно, где имеет смысл использовать его:

leftOffset = -(~~$('html').css('padding-left').replace('px', '') + ~~$('body').css('margin-left').replace('px', '')),

Источник:

Смотрите раздел Взаимодействие с точками

Преобразование строк в числа

console.log(~~-1);    // -1
console.log(~~0);     // 0
console.log(~~1);     // 1
console.log(~~"-1");  // -1
console.log(~~"0");   // 0
console.log(~~"1");   // 1
console.log(~~true);  // 1
console.log(~~false); // 0

~ -1 равно 0

if (~someStr.indexOf("a")) {
  // Found it
} else  {
  // Not Found
}

источник

Тильда (~) имеет алгоритм - (N + 1)

Например:

~0 = -(0+1) = -1
~5 = -(5+1) = -6
~-7 = -(-7+1) = 6

Двойная тильда это - (- (N + 1) +1)

Например:

~~5 = -(-(5+1)+1) = 5
~~-3 = -(-(-3+1)+1) = -3

Тройная тильда - - (- (- (N + 1) +1) +1)

Например:

~~~2 = -(-(-(2+1)+1)+1) = -3
~~~3 = -(-(-(3+1)+1)+1) = -4