Типы данных

Проверка типа во время компиляции часто более предпочтительна в крупных проектах, поскольку по мере роста проекта гибкость типов данных обычно становится менее важной, чем необходимость отслеживания ошибок на максимально ранних стадиях. Вот почему по умолчанию компилятор ActionScript в инструментах Flash Professional и Flash Builder установлен для работы в строгом режиме.

Чтобы обеспечить возможность проверки во время компиляции, компилятору необходимо располагать сведениями о типах данных для переменных и выражений в программном коде. Чтобы явным образом объявить тип данных для переменной, добавьте оператор двоеточия ( : ) с последующим указанием типа данных в качестве суффикса к имени переменной. Чтобы связать тип данных с параметром, используется оператор двоеточия с последующим указанием типа данных. Например, в следующем программном коде к параметру xParam добавляются сведения о типе данных, а затем объявляется переменная myParam с явно указанным типом данных.

function runtimeTest(xParam:String) 
{ 
    trace(xParam); 
} 
var myParam:String = "hello"; 
runtimeTest(myParam);

В строгом режиме работы компилятор ActionScript сообщает о несоответствиях типов как об ошибках компиляции. Например, в следующем программном коде объявляется параметр функции xParam с типом Object, но затем предпринимается попытка назначить этому параметру значения типа String и Number. При этом в строгом режиме работы компилятора выдаются ошибки.

function dynamicTest(xParam:Object) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; // compiler error in strict mode 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; // compiler error in strict mode 
        trace("Number: " + myNum); 
    } 
}

Однако даже в строгом режиме можно селективно отключать проверку типа во время компиляции, оставляя незаполненной правую часть инструкции присваивания. Можно пометить переменную или выражение как не имеющие типа, либо пропустив аннотацию типа, либо используя специальную аннотацию типа с помощью звездочки ( * ). Например, если параметр xParam в предыдущем примере изменяется так, что больше не имеет аннотации типа, программный код компилируется в строгом режиме:

function dynamicTest(xParam) 
{ 
    if (xParam is String) 
    { 
        var myStr:String = xParam; 
        trace("String: " + myStr); 
    } 
    else if (xParam is Number) 
    { 
        var myNum:Number = xParam; 
        trace("Number: " + myNum); 
    } 
} 
dynamicTest(100) 
dynamicTest("one hundred");

Проверки типа при выполнении в ActionScript 3.0 происходит независимо от того, идет работа в строгом или в стандартном режиме. Рассмотрите ситуацию, в которой значение 3 передается в качестве аргумента функции, ожидающей массив. В строгом режиме компилятор создаст ошибку, поскольку значение 3 не совместимо с типом данных Array. Если отключить строгий режим и выполнять программу в стандартном режиме, компилятор пропустит несоответствие типов, но при проверке типа во время выполнения возникнет ошибка выполнения.

В следующем примере показана функция с именем typeTest() , которая ожидает аргумент Array, но ей передается значение 3. Это вызывает ошибку выполнения в стандартном режиме, поскольку значение 3 не является членом объявленного для параметра типа данных (Array).

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum:Number = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0 standard mode

Также возможны ситуации, когда ошибки выполнения возникают при работе в строгом режиме. Это возможно в тех случаях, если используется строгий режим, но выключена проверка типа при компиляции при использовании переменных без указания типа. Если используются переменные без указания типа, проверка типа не отключается полностью, а просто откладывается до выполнения программного кода. Например, если для переменной  myNum в предыдущем примере не объявлен тип данных, компилятор не сможет определить несоответствие типов, но при выполнении кода возникнет ошибка выполнения, поскольку сравнивается значение при выполнении переменной myNum , установленное с помощью команды присваивания и равное 3, с типом xParam , для которого задан тип данных Array.

function typeTest(xParam:Array) 
{ 
    trace(xParam); 
} 
var myNum = 3; 
typeTest(myNum);  
// run-time error in ActionScript 3.0

Проверка типа при выполнении позволяет более гибко использовать наследование, чем при проверке во время компиляции. Откладывая проверку типа до времени выполнения, стандартный режим позволяет ссылаться на свойства подкласса даже в том случае, если выполняется восходящее преобразование . Восходящее преобразование происходит, если для объявления типа экземпляра класса используется базовый класс, а для его инициации используется подкласс. Например, можно создать класс с именем ClassBase, который может быть расширен (классы с атрибутом final не могут быть расширены).

class ClassBase 
{ 
}

Затем можно создать подкласс ClassBase с именем ClassExtender, у которого есть одно свойство с именем someString , как показано в следующем примере.

class ClassExtender extends ClassBase 
{ 
    var someString:String; 
}

Используя оба класса, можно создать экземпляр класса, объявляемый с типом данных ClassBase, но инициируемый с помощью конструктора ClassExtender. Восходящее преобразование считается безопасной операцией, поскольку базовый класс не содержит каких-либо свойств или методов, которых не было бы в подклассе.

var myClass:ClassBase = new ClassExtender();

В то же время подкласс содержит свойства или методы, которые отсутствуют в базовом классе. Например, класс ClassExtender содержит свойство someString , не существующее в классе ClassBase. В стандартном режиме работы ActionScript 3.0 можно ссылаться на это свойство с помощью экземпляра myClass , не создавая ошибки во время компиляции, как показано в следующем примере.

var myClass:ClassBase = new ClassExtender(); 
myClass.someString = "hello"; 
// no error in ActionScript 3.0 standard mode

Оператор is позволяет проверить, является ли переменная или выражение членом определенного типа данных. В предыдущих версиях ActionScript оператор instanceof обеспечивал данную функциональную возможность, но в ActionScript 3.0 оператор instanceof не следует использовать для проверки принадлежности к типу данных. Оператор is необходимо использовать вместо оператора instanceof для проверки типа вручную, поскольку выражение x instanceof y проверяет только цепочку прототипа x на существование y (а в ActionScript 3.0 цепочка прототипа не передает полной картины иерархии наследования).

Оператор is проверяет правильность иерархии наследования и может применяться для проверки не только того, является ли объект экземпляром определенного класса, но также является ли объект экземпляром класса, реализующего определенный интерфейс. В следующем примере создается экземпляр класса Sprite с именем mySprite , который использует оператор is для проверки того, является ли mySprite экземпляром классов Sprite и DisplayObject, а также реализует ли он интерфейс IEventDispatcher.

var mySprite:Sprite = new Sprite(); 
trace(mySprite is Sprite); // true 
trace(mySprite is DisplayObject);// true 
trace(mySprite is IEventDispatcher); // true

Оператор is проверяет иерархию наследования и правильно диагностирует, что mySprite совместим с классами Sprite и DisplayObject (класс Sprite является подклассом класса DisplayObject). Оператор is также проверяет, действительно ли mySprite наследует от какого-либо класса, в котором реализован интерфейс IEventDispatcher. Поскольку класс Sprite наследует от класса EventDispatcher, в котором реализован интерфейс IEventDispatcher, оператор is правильно сообщает, что в классе mySprite также реализован этот интерфейс.

В следующем примере показаны те же тесты из предыдущего примера, но с оператором instanceof вместо оператора is . Оператор instanceof правильно определяет, что класс mySprite является экземпляром классов Sprite или DisplayObject, но он возвращает результат false при попытке проверить, реализует ли класс mySprite интерфейс IEventDispatcher.

trace(mySprite instanceof Sprite); // true 
trace(mySprite instanceof DisplayObject);// true 
trace(mySprite instanceof IEventDispatcher); // false

Оператор as также позволяет проверить, является ли переменная или выражение членом определенного типа данных. В отличие от оператора is оператор as не возвращает логические значения. При этом оператор as возвращает значение выражения вместо true или значение null вместо false . В следующем примере показан результат использования оператора as вместо оператора is в простом случае проверки. Определяется, действительно ли экземпляр Sprite является членом типов данных DisplayObject, IEventDispatcher и Number.

var mySprite:Sprite = new Sprite(); 
trace(mySprite as Sprite);                 // [object Sprite] 
trace(mySprite as DisplayObject);                 // [object Sprite] 
trace(mySprite as IEventDispatcher);                 // [object Sprite] 
trace(mySprite as Number);                                       // null

При использовании оператора as операнд справа должен быть типом данных. Попытка использовать в качестве операнда справа выражение вместо типа данных приведет к ошибке.

Логический тип данных (Boolean) включает два значения: true и false . Никакие другие значения для переменных с типом Boolean не действительны. По умолчанию для переменной с типом Boolean, которая объявлена, но не инициализирована, устанавливается значение false .

Тип данных int предназначен для внутреннего хранения информации в виде 32-разрядных целых чисел и включает подмножество целых чисел от

-2147483648 (-2 ³¹ ) до 2147483647 (2 ³¹ - 1) включительно. В предыдущих версиях ActionScript предлагался только тип данных Number, в котором использовались как целые числа, так и числа с плавающей точкой. В ActionScript 3.0 теперь есть доступ к двоичным типам нижнего уровня для работы с 32-разрядными целыми числами со знаком и без знака. Если переменная не использует числа с плавающей точкой, то применение типа данных int вместо типа данных Number позволит ускорить обработку данных и сделать ее более эффективной.

Для целых значений, выходящих за пределы диапазона минимального и максимального значений, используйте тип данных Number, с помощью которого можно обрабатывать значения в промежутке между положительным и отрицательным значением 9007199254740992 (53-разрядные целые значения). По умолчанию значение переменной с типом данных int равно 0.

Тип данных Null содержит только одно значение null . Это значение по умолчанию для типа данных String и всех классов, которые определяют сложные типы данных, включая класс Object. Никакой другой из примитивных типов данных, таких как Boolean, Number, int и uint, не может содержать значение null . Во время выполнения значение null преобразуется в соответствующее значение по умолчанию при попытке назначить значение null переменным типа Boolean, Number, int или uint. Нельзя использовать этот тип данных в качестве аннотации типа.

В ActionScript 3.0 тип данных Number может быть представлен целыми числами, целыми числами без знака, а также числами с плавающей точкой. В то же время, чтобы повысить производительность, необходимо использовать тип данных Number только для целых значений, которые не помещаются в 32-разрядных типах int и uint , или для значений с плавающей точкой. Для сохранения числа с плавающей точкой включите в него десятичную точку. Если десятичная точка пропущена, число сохраняется как целое.

В типе данных Number используется 64-разрядный формат с двойной точностью в соответствии со стандартом IEEE для двоичных арифметических операций с плавающей точкой (IEEE-754). Этот стандарт определяет, как числа с плавающей точкой сохраняются с помощью 64 доступных разрядов. Один разряд используется для обозначения того, положительным или отрицательным является число. Одиннадцать разрядов используются для экспоненциальной части, которая сохраняется с основанием 2. Оставшиеся 52 разряда используются для хранения значащей части числа (также называемой мантиссой ), которая является числом, возводимым в степень, указанную в экспоненциальной части.

Используя некоторые из этих разрядов для хранения экспоненциальной части, тип данных Number может сохранять числа с плавающей точкой, значительно превышающие значения, которые бы получались, если бы все разряды были отведены под значащую часть числа. Например, если бы тип данных Number использовал все свои 64 разряда для сохранения значащей части числа, в нем можно было бы сохранить значение 2 ⁶⁵ - 1. Используя 11 разрядов для хранения экспоненциальной части, тип данных Number может возводить свою значимую часть в степень 2 ¹⁰²³ .

Максимальное и минимальное значения, которые может воспроизводить класс Number, хранятся в статических свойствах класса Number, называемых Number.MAX_VALUE и Number.MIN_VALUE .

Number.MAX_VALUE == 1.79769313486231e+308 
Number.MIN_VALUE == 4.940656458412467e-324

Расплатой за возможность использовать столь огромный диапазон значений является точность. Тип данных Number использует 52 разряда для хранения значимой части числа, в результате числа, которым требуется больше 52 разрядов для точного воспроизведения, например 1/3, отображаются как приближенные значения. Если для приложения требуется абсолютная точность в работе с десятичными числами, необходимо использовать программное обеспечение, реализующее десятичные арифметические операции с плавающей точкой в качестве альтернативы двоичным операциям.

При сохранении целых значений с помощью типа данных Number для значимой части числа используется только 52 разряда. Тип данных Number использует эти 52 разряда и специальный скрытый разряд для представления целых чисел в диапазоне от -9007199254740992 (-2 ⁵³ ) до 9007199254740992 (2 ⁵³ ).

Значение NaN используется не только как значение по умолчанию для переменных с типом Number , но также в качестве результата любой операции, которая должна возвращать число, но не делает этого. Например, при попытке рассчитать квадратный корень отрицательного числа результатом будет NaN . Другими специальным значениями типа Number являются плюс бесконечность и минус бесконечность .

Тип данных String передает последовательность 16-разрядных символов. Для внутреннего хранения значений с типом String используются символы Unicode и формат UTF-16. Значения с типом данных String являются постоянными, такими же, как и при программировании в языке Java. Операция со значением String возвращает новый экземпляр этой строки. По умолчанию значением для переменной, объявленной с типом данных String, является null . Значение null не равнозначно пустой строке ( "" ). Значение null обозначает, что в переменной не сохранено значение, а пустая строка обозначает, что в переменной сохранено значение строкового типа String, не содержащее символов.

Для внутреннего хранения типа данных uint используются 32-разрядные целые числа без знака. Этот тип данных содержит диапазон целых значений от 0 до 4294967295 (2 ³² - 1) включительно. Тип данных uint применяется в особых случаях, когда необходимы положительные целые числа. Например, следует использовать тип данных uint для передачи значений цвета пиксела, поскольку тип данных int имеет внутренний разряд для знака, не удобный для обработки цветовых значений. Для целых значений, больших, чем максимальное значение uint, следует использовать тип данных Number, который позволяет обрабатывать 53-разрядные целые значения. По умолчанию значение переменной с типом данных uint равно 0.

Тип данных void содержит только одно значение undefined . В предыдущих версиях ActionScript значение undefined было значением по умолчанию для экземпляров класса Object. В ActionScript 3.0 значением по умолчанию для экземпляров Object является null . При попытке назначить значение undefined экземпляру объекта Object значение преобразуется в null . Переменной, для которой не задан тип, можно назначить только значение undefined . Переменные без указания типа — это переменные, для которых либо отсутствует любая аннотация типа, либо указан символ звездочки ( * ) в качестве аннотации типа. Значение void можно использовать только для аннотации возвращаемого типа.

Тип данных Object определяется классом Object. Класс Object служит базовым классом для всех определений классов в ActionScript. В ActionScript 3.0 версия типа данных Object отличается от предыдущих версий тремя особенностями. Во-первых, тип данных Object больше не является типом данных по умолчанию, назначаемым переменным, для которых не задан тип. Во-вторых, тип данных Object больше не включает значение undefined , которое используется в качестве значения по умолчанию для экземпляров Object. В-третьих, в ActionScript 3.0 значением по умолчанию для экземпляров класса Object является null .

В предыдущих версиях ActionScript переменной без аннотации типа автоматически назначался тип Object. В ActionScript 3.0 это не так, здесь реализована концепция переменной, действительно не имеющей типа. Переменные без аннотации типа теперь расцениваются как переменные, не имеющие типа. Если требуется, чтобы читателям программного кода были ясны намерения автора оставить переменную без типа, можно использовать символ звездочки ( * ) для аннотации типа, что будет эквивалентно пропущенной аннотации типа. В следующем примере показаны две эквивалентные инструкции, обе они объявляют переменную x , не имеющую типа.

var x 
var x:*

Только переменная, не имеющая типа, может содержать значение undefined . Если попытаться назначить значение undefined переменной, имеющей тип данных, среда выполнения преобразует значение undefined в значение по умолчанию этого типа данных. Для экземпляров типа данных Object значением по умолчанию является null , а это значит, что при попытке присвоить значение undefined экземпляру Object значение преобразуется в null .