Що таке оператор JavaScript >>> і як ним користуватися?

Я дивився на код від Mozilla, який додав метод фільтру до масиву, і він мав рядок коду, який мене збентежив.

var len = this.length >>> 0;

Я ніколи не бачив, щоб раніше >>> використовувався в JavaScript.
Що це таке і що він робить?

Він не просто конвертує нечислові числа, а перетворює їх у числа, які можуть бути виражені як 32-бітні неподписані вставки.

Хоча Числа JavaScript є подвійний точності поплавці (*), оператори бітові ( <<, >>, &, |і ~) визначені в термінах операцій на 32-розрядних цілих чисел. Виконуючи побітну операцію, перетворять число в 32-розрядний підписаний int, втрачаючи будь-які дроби і біти вищого місця, ніж 32, перед тим як робити обчислення, а потім перетворювати назад в число.

Таким чином, операція побітових операцій без фактичного ефекту, як, наприклад, зсув праворуч на 0 біт >>0, - це швидкий спосіб округлити число і переконатися, що він знаходиться в діапазоні 32-бітових інт. Крім того, потрійний >>>оператор, виконуючи свою непідписану операцію, перетворює результати свого обчислення в Число як непідписане ціле число, а не підписане ціле число, яке роблять інші, тож його можна використовувати для перетворення негативів у 32-розрядне-два доповнення версія як велика кількість. Використання >>>0гарантує, що у вас є ціле число між 0 і 0xFFFFFFFF.

У цьому випадку це корисно, оскільки ECMAScript визначає індекси масиву в термінах 32-бітових неподписаних ints. Отже, якщо ви намагаєтесь реалізувати array.filterтаким чином, що точно дублює те, що говорить стандарт ECMAScript Fifth Edition, ви додасте число до 32-бітного неподписаного int, як це.

(Насправді існує мало практична потреба в цьому , як ми сподіваємося , що люди не будуть установки array.lengthна 0.5, -1, 1e21або 'LEMONS'. Але це автори JavaScript ми говоримо про, так що ви ніколи не знаєте ...)

Підсумок:

1>>>0            === 1
-1>>>0           === 0xFFFFFFFF          -1>>0    === -1
1.7>>>0          === 1
0x100000002>>>0  === 2
1e21>>>0         === 0xDEA00000          1e21>>0  === -0x21600000
Infinity>>>0     === 0
NaN>>>0          === 0
null>>>0         === 0
'1'>>>0          === 1
'x'>>>0          === 0
Object>>>0       === 0

(*: ну, вони визначаються як поводяться як плавучі. Мене не здивувало б, якщо якийсь механізм JavaScript насправді використовував ints, коли це можливо, з міркувань продуктивності. Але це буде детальною інформацією про реалізацію, яку ви не отримаєте. перевага.)

Оператор безпідписаного правого зсуву використовується у всіх реалізаціях методу масиву Mozilla, щоб переконатися, що lengthвластивість є непідписаним 32-бітовим цілим числом .

lengthВластивість об'єктів масиву буде описано в описі як:

Кожен об’єкт масиву має властивість довжини, значення якого завжди є неотрицательним цілим числом менше 2 ³² .

Цей оператор є найкоротшим способом його досягнення, внутрішні методи масиву використовують ToUint32операцію, але цей метод недоступний і існує в специфікації для цілей реалізації.

Реалізації додатків масиву Mozilla намагаються бути сумісними з ECMAScript 5 , подивіться опис Array.prototype.indexOfметоду (§ 15.4.4.14):

1. Нехай O є результатом виклику ToObject, передаючи це значення 
   як аргумент.
2. Нехай lenValue є результатом виклику внутрішнього методу O з [[Get]] 
   аргумент "довжина".
3. Нехай len буде ToUint32 (lenValue) .
….

Як ви бачите, вони просто хочуть відтворити поведінку ToUint32методу на відповідність специфікації ES5 щодо впровадження ES3, і, як я вже говорив раніше, не підписаний правий оператор зміни є найпростішим способом.

Це непідписаний правий оператор зсуву бітів . Різниця між цим та підписаним оператором зсуву правого біта полягає в тому, що непідписаний правий оператор зсуву бітів ( >>> ) заповнює нулі зліва, а підписаний оператор зсуву правого біта ( >> ) заповнює біт знака, таким чином збереження знака числового значення при зміщенні.

Driis досить пояснив, що таке оператор і що він робить. Ось значення, яке стоїть за цим / чому воно було використано:

Зміна будь-якого напрямку на "" 0"повертає початковий номер і буде передана nullна 0. Здається, що прикладний код, який ви шукаєте, використовує this.length >>> 0для забезпечення lenчисельності, навіть якщо this.lengthвін не визначений.

Для багатьох людей бітові операції незрозумілі (і Дуглас Крокфорд / jslint пропонує проти використання таких речей). Це не означає, що це неправильно робити, але існують більш сприятливі та звичні методи, щоб зробити код більш читабельним. Більш чіткий спосіб забезпечити lenце 0- один із наступних двох методів.

// Cast this.length to a number
var len = +this.length;

або

// Cast this.length to a number, or use 0 if this.length is
// NaN/undefined (evaluates to false)
var len = +this.length || 0; 

>>>- це непідписаний правий оператор зміни ( див. стор. 76 специфікації JavaScript 1.5 ), на відміну >>від підписаного оператора правої зміни.

>>>змінює результати зміщення від'ємних чисел, оскільки це не зберігає бітовий знак при зміщенні . Наслідки цього можна зрозуміти на прикладі перекладача:

$ 1 >> 0
1
$ 0 >> 0
0
$ -1 >> 0
-1
$ 1 >>> 0
1
$ 0 >>> 0
0
$ -1 >>> 0
4294967295
$(-1 >>> 0).toString(16)
"ffffffff"
$ "cabbage" >>> 0
0

Отже, що, ймовірно, призначено зробити тут, - це отримати довжину, або 0, якщо довжина не визначена або не є цілим числом, як показано у "cabbage"прикладі вище. Я думаю, що в цьому випадку можна впевнено припустити, що this.lengthцього ніколи не буде < 0. Тим не менш, я заперечую, що цей приклад - це неприємний злом з двох причин:

1. Поведінка <<<при використанні негативних чисел, побічний ефект, ймовірно, не призначений (або може виникнути) у наведеному вище прикладі.

2. Намір коду не очевидний , оскільки підтверджується наявність цього питання.

Найкраща практика, ймовірно, використовувати щось більш читабельне, якщо продуктивність не є абсолютно критичною:

isNaN(parseInt(foo)) ? 0 : parseInt(foo)

Дві причини:

1. Результат >>> - це "інтеграл"

2. undefined >>> 0 = 0 (оскільки JS буде намагатися примусити LFS до числового контексту, це також буде працювати для "foo" >>> 0 і т.д.)

Пам'ятайте, що числа в JS мають внутрішнє подання подвійне. Це просто "швидкий" спосіб базової розумності введення для довжини.

Однак -1 >>> 0 (ой, ймовірно, не бажаної довжини!)

Приклад Java-коду нижче добре пояснює:

int x = 64;

System.out.println("x >>> 3 = "  + (x >>> 3));
System.out.println("x >> 3 = "  + (x >> 3));
System.out.println(Integer.toBinaryString(x >>> 3));
System.out.println(Integer.toBinaryString(x >> 3));

Вихід такий:

x >>> 3 = 536870904
x >> 3 = -8
11111111111111111111111111000
11111111111111111111111111111000