Что такое оператор JavaScript >>> и как вы его используете?

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

var len = this.length >>> 0;

Я никогда не видел >>> используется в JavaScript раньше.
Что это такое и что оно делает?

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

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

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

В этом случае это полезно, потому что ECMAScript определяет индексы массива в терминах 32-битных беззнаковых целых. Поэтому, если вы пытаетесь реализовать array.filterтаким образом, который бы точно повторял то, что говорится в стандарте ECMAScript Fifth Edition, вы бы преобразовали число в 32-битное целое число без знака, как это.

(На самом деле существует мало практическая потребность в этом , как мы надеемся , что люди не будут установки 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 действительно использует int, когда это возможно, по соображениям производительности. Но это будет деталь реализации, которую вы не захотите взять. преимущество.)

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

lengthСвойство объектов массива будет описано в описании как:

Каждый объект Array имеет свойство length, значение которого всегда является неотрицательным целым числом, меньшим 2 ³² .

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

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

1. Пусть O будет результатом вызова ToObject с передачей значения this 
   в качестве аргумента.
2. Пусть lenValue будет результатом вызова внутреннего метода [[Get]] для O с 
   аргумент "длина".
3. Пусть len будет ToUint32 (lenValue) .
....

Как вы можете видеть, они просто хотят воспроизвести поведение ToUint32метода в соответствии со спецификацией ES5 для реализации ES3, и, как я уже говорил, оператор беззнакового сдвига вправо является самым простым способом.

Это оператор беззнакового сдвига вправо . Разница между этим и подписанным правом оператора сдвига бит , является то , что без знака правый бит - оператор сдвига ( >>> ) заполняется нулями слева, и подписал правый бит оператор сдвига ( >> ) заполняется знаковый бит, таким образом , сохранение знака числового значения при смещении.

Дриис достаточно объяснил, что такое оператор и что он делает. Вот смысл этого / почему он был использован:

Сдвиг любого направления на 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 1.5 спецификации JavaScript ), в отличие от >>, с подписью правильного оператора сдвига.

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

$ 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 имеют внутреннее представление double. Это просто «быстрый» способ ввода здравомыслия в длину.

Тем не менее , -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