Московский физико-технический институт
Опубликован: 23.12.2005 | Доступ: свободный | Студентов: 2833 / 242 | Оценка: 4.61 / 4.44 | Длительность: 27:18:00
ISBN: 978-5-9556-0051-2
Лекция 2:

Базовые понятия Action Script

Необычные операторы (специфика Java и Флэш МХ)

Сначала мы поговорим об одном операторе, который отсутствует в С++, но присутствует в Java и Флэш МХ. Это оператор беззнакового сдвига вправо >>>. Он позволяет сдвигать вправо все биты, включая знаковый; таким образом, использование этого оператора избавляет нас от побочных эффектов, связанных с переходом старших битов при сдвиге влево в знаковый разряд. Если использовать затем обычный сдвиг вправо, то знак сохраняется навечно (или, если разобраться, что происходит в дополнительном коде, то там знаковый бит сдвигается, как и положено, но на его старом месте каждый раз снова появляется единица). А вот в результате беззнакового сдвига ничего такого не происходит: единица из знакового бита спокойно "выезжает", оставляя там ноль. Вот пример, иллюстрирующий это.

trace((3 << 29).toString(2) + " = (3 << 29).toString(2)")
trace((3 << 30).toString(2) + " = (3 << 30).toString(2)")
trace((Math.pow(2, 31) + Math.pow(2, 30)).toString(2) +
   " = 2^31 + 2^30 в двоичном виде");
trace(((Math.pow(2, 31) + Math.pow(2, 30)) >> 5).toString(2) +
   " - результат >> 5");
trace(((Math.pow(2, 31) + Math.pow(2, 30)) >>> 5).toString(2) +
   " - результат >>> 5");

Выполнение этого кода дает следующий результат:

1100000000000000000000000000000 = (3 << 29).toString(2)
-1000000000000000000000000000000 = (3 << 30).toString(2)
-1000000000000000000000000000000 = 2^31 + 2^30 в двоичном виде
-10000000000000000000000000 - результат >> 5
110000000000000000000000000 - результат >>> 5

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

Теперь перейдем к необычным операторам, которых нет и в Java. Это операторы === (три последовательных знака "равно") и !== (восклицательный знак и за ним два знака равенства). Это так называемые операторы проверки на "строгое равенство". Дело в том, что обычные операторы == и != сначала конвертируют оба операнда к одному и тому же типу и лишь затем производят сравнение. Таким образом, значением выражения 5.5 == "5.5" является true. А вот при сравнении с помощью операторов === и !== учитывается и тип сравниваемых операндов. Так что 5.5 === "5.5" выдает false. Заметим, что именно на "строгое равенство" проверяются выражения в операторе switch. Также только === и !== позволяют отличить друг от друга null и undefined.

Далее следует сказать о дополнительных унарных операторах ( приоритет их такой же, как и у прочих унарных): typeof и void. Про typeof мы уже говорили, он определяет принадлежность объекта к одному из встроенных типов и выдает строковое название этого типа. Что же касается оператора void, то он может быть применен к любому выражению и возвращает всегда undefined. Придумать этому оператору естественное применение довольно сложно. Разве что при отладке можно с его помощью временно отменять передачу в функцию какого-то сложного аргумента (быстрее написать void, чем поставить знаки комментария с двух сторон).

К операторам сравнения во Флэш МХ добавляется оператор instanceof (он, правда, есть и в Java). Этот оператор проверяет, является ли левый операнд объектом подкласса правого операнда. Подробнее об этом операторе мы еще поговорим в лекции, посвященной наследованию.

Устаревшие операторы

От четвертой версии Флэш нам достались в наследство специальные операторы для сравнения строк. То есть перед сравнением выражений между собой эти выражения преобразуются в строки. Эти операторы не рекомендуется применять во Флэш МХ, однако вам стоит знать об их существовании (хотя бы для того, чтобы не использовать в качестве идентификаторов соответствующие лексемы). Вот список этих операторов:

  • lt - меньше (less than)
  • gt - больше (greater than)
  • le - меньше или равно (less or equal)
  • ge - больше или равно (greater or equal)
  • eq - равно (equal)
  • ne - не равно (not equal)

Кроме того, из Флэш 4 перешел во Флэш 5 и Флэш МХ набор логических операторов, полностью аналогичных операторам ! (отрицание), && (логическое "И") и || (логическое "ИЛИ"). Вот они:

  • and - логическое "И"
  • or - логическое "ИЛИ"
  • not - логическое "НЕ"

Также имеется устаревшая форма оператора сравнения != (возвращающего true, если сравниваемые выражения не равны). Этот оператор имеет такой вид: <> (его можно встретить, скажем, в языке Бейсик). Итак, вносим в нашу таблицу устаревших операторов

  • <> - оператор "НЕ РАВНО"

Наконец, последним в списке устаревших операторов является оператор, предназначенный для склеивания строк:

  • add - конкатенация строк

Этот оператор преобразует свои операнды в строки, а затем работает точно так же, как со строками работает оператор +.

Еще раз повторим, что все эти операторы считаются устаревшими и использовать их не рекомендуется.

Работа различных операторов со строками

Во Флэш МХ многие стандартные операторы способны работать со строками. В первую очередь, это оператор " + ", используемый для сцепления строк. Также все операторы сравнения могут использоваться для сравнения строк согласно их лексикографическому порядку. Например: выражение "five" >= "Five" имеет значение true, а значением выражения "Seven" < "Five" является false. Следует только учитывать, что если один из операндов является числом, то, в отличие от оператора " + ", здесь произойдет преобразование к числовому типу. Таким образом, значением выражения "0x5" < 4 будет false, хотя "0x5" < "4" дает true. Наконец, имейте в виду, что если преобразование строкового оператора в число пройдет неудачно (получится Number.NaN ), то результатом выполнения сравнения будет undefined.