Почему XOR 0 убирает дробную часть числа?
Почему число получается целым, уже объяснил Stranger  in the Q 
Я же постараюсь объяснить, как это работает, и почему оно не лучше Math.floor:
В js тип number представлен числами двойной точности по стандарту кодирования IEEE 754, а это значит, что 53 бита выделяются под значимую часть (старший бит - бит знака, если 1 - то число отрицательное) и 11 бит под экспоненту (старший бит опять же бит знака), всего выходит 64 бита. Притом данный стандарт позволяет абсолютно точно работать с целыми числами до ±252 и поэтому до не давнего времени в js честного int не было.
Теперь к бинарным (не нравится мне перевод "побитовый") операциям, как известно "исключающее или" (xor, ^) с нулем, а так же "или" (or, |) с нулем не меняют число, возвращая другой операнд в неизменном виде. Но тут вклинивается стандарт js и говорит, что бинарные операции выполняются над signed int32 представлением числа и при представлении можно просто отбросить все лишнее, что движки и делают.
Как отбросить все лишние? Да просто, движок js прекрасно знает, в какой части числа расположена значимая часть, он просто берет младшие 32 бита значимой части и кладет их в int32 контейнер ну и еще переносит бит знака на свое место. Обратное преобразование похоже - в нулевой float64 контейнер раскладываем: старший бит (знак) на свое место, остальные 31 бит - на свое.

А теперь давайте поэкспериментируем в обычной браузерной консоли:Math.floor(1.1) // 1
parseInt(1.1) // 1
1.1 | 0 // 1
1.1 ^ 0 // 1 - как уже писал выше, эффект будет 1 в 1, как и с |

// пока все было ок, но как насчет отрицательных чисел?
Math.floor(-1.1) // -2 - округляем в сторону -Infinity
parseInt(-1.1) // -1 - отбрасываем экспоненту
-1.1 | 0 // -1 - отбрасываем экспоненту и не только (но тут не имеет значения пока)

// попробуем с чем-нибудь побольше
2 ** 31 // 2147483648
2147483648 | 0 // -2147483648
/*
не зная как преобразовывается число выше, это было бы не очевидно
но смотрим выше "он просто берет младшие 32 бита значимой части и кладет их в int32 контейнер"
2 ** 31 в двоичном виде - это единичка и 31 нолик
и эта единичка попала в бит знака при переноси в int32
тем самым мы получили самое маленькое число в int32
*/

// давайте еще пример, набью как я большое число от балды:
34646456436346346212424 // 3.464645643634635e+22
34646456436346346212424 | 0 // 1178599424
/*
ну в первом примере мы видим интересную особенность чисел с плавающей запятой
мы можем хранить не только дробные числа, но и очень большие целые, правда с потерей точности
e+22 - это и есть экспонента, это значит число до e нужно умножить на основание системы счисления (10) в степени +22
а при бинарной операции эта экспонента отбрасывается, как и старшие биты значимой части
в 32 младших битах осталось 1178599424
забавно, что я случайно вбил такое число, у которого 32 бит содержал 0 (шансы были 50/50)
если бы там оказалась 1, то я бы вновь получил отрицательное число
*/
Лучший способ 
let v = 999.99|0; // out: 999