Числа (тип number)

Если описывать, зачем нужны числа в ActionScript, то для этого понадобится слишком много времени и бумаги. Скажем проще: числа нужны везде. Действительно, очень и очень трудно придумать алгоритм, в котором не использовались бы числа. Знание методов работы с числами и особенностей их представления в ActionScript чрезвычайно важно для практики.

Виды чисел в ActionScript
Исторически числа при описании вычислений на компьютере принято делить на целые (integer) и действительные (real), или числа с плавающей точкой (floatingpoint). Первому типу соответствуют литералы, образованные только цифрами (например, 122 или —896), второму — цифрами и десятичной точкой (5.8905 или 0.9067). Раньше такое деление было оправданно ввиду крайней ограниченности ресурсов компьютеров (целые числа требовали меньше памяти, чем числа с плавающей точкой). Современные машины достигли достаточной мощности, чтобы во всех случаях можно было использовать тип представления floating-point. Поэтому, для простоты, в ActionScript не существует типов real и integer, а все числа относятся к типу number, которому соответствуют 64-битные числа с плавающей точкой. Различие же между целыми числами и числами с дробной частью исключительно визуальное.

Некоторые операторы и функции языка могут работать только с целыми числами.


Так как к типу number относятся числа с плавающей точкой, то для обеспечения корректной работы этих инструментов языка существуют внутренние методы, проводящие преобразования в 32-битные и 16-битные целые числа. Таким образом, разделение на целые числа и числа с плавающей точкой в ActionScript все же имеется, но только на уровне реализации.

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

Чтобы система восприняла число как восьмеричное, оно должно начинаться с нуля. Естественно, что остальные цифры не должны быть больше семи. При преобразовании в строку восьмеричное число приводится к десятичному основанию (поэтому при передаче его функции trace() в качестве аргумента в панель Output выводится десятичное число).

trace (0210]; // Выводит 136 ( 136 8 * 2 8 * 1 8 * 0 2 1 0 = + + )

Ввиду того, что любое целое число, начинающееся с нуля, система воспримет как восьмеричное, важно следить, чтобы при работе алгоритма не возникало чисел с незначащими ведущими нулями.

С похожей проблемой, кстати, мы встретимся, когда будем создавать проект этой главы — Flash-калькулятор.

Более интересным и важным для практики является шестнадцатеричный формат чисел.


Цифрами в нем служат цифры от 0 до 9 и буквы латинского алфавита от А до F. В ActionScript шестнадцатеричные числа задаются при помощи приставки «0х». При автоматическом преобразовании в стро-ки числа по основанию 16, подобно восьмеричным числам, переводятся в десятичный формат.

trace (0xFF); // Выводит: 255 ( 1 0 16 * 15 16 * 15 + )

Шестнадцатеричные числа используются, прежде всего, для задания цветов. Обратите внимание, что формула выбранного оттенка на панели Color Mixer представляет собой шестизначное шестнадцатеричное число. Первые два его разряда отвечают за интенсивность красной составляющей, третья и четвертая цифры — зеленой, пятая и шестая — синей. Например, белому цвету соответствует формула 0xFFFFFF, черному — 0x000000, зеленому — 0x00DD00 и т, д. Более подробно принципы кодирования цветов мы обсудим, когда будем разбирать класс Color. Также с шестнадцатеричным форматом чисел мы встретимся, когда будем обсуждать введение в строки символов Unicode.

На уровне реализации языка числам в восьмеричной и шестнадцатеричной системах счисления соответствуют 32-битовые целые числа. Это означает, что при помощи них нельзя представить значение, большее 232 = 4294962795.


Поэтому запись вроде 0xFFFF01D5A нe имеет смысла.

Помимо обычных, существуют и особые числовые величины. Они служат для обозначения бесконечности, минимального и максимального вычислимого значения, недопустимой величины. Более обстоятельно мы поговорим о них ниже.

Особенности представления чисел
В математике считается, что множество чисел бесконечно. Это означает, что число может бытькак сколь угодно большим, так и сколь угодно малым. Оно может быть образовано любым количеством цифр. Так, существуют бесконечные дроби и бесконечные трансцендентальные константы (например, число π или число e). Но в реальном мире все конечно. Даже Вселенная имеет границы. Ограничена и память компьютера. Атак как на каждую цифру числа нужно выделить несколько бит, то любая вычислительная машина считает с конечной точностью.

Точность вычислений определяется тем, сколько памяти выделяется на хранение каждого числа. На современных компьютерах для представления чисел с плавающей точкой используется 64-битный формат двойной точности (соответственно формат одинарной точности 32-битный). Это позволяет напрямую закодировать 264—18 446 744 073 709 551 616 целых чисел.


Совсем немного, не правда ли? На практике приходится работать с куда большим количеством числовых значений.

Как же «запихнуть» в скромные 64 бита все необходимые числа?

Решением описанной сложности является формат представления чисел с использованием плавающей точки. Основная его идея заключается в следующем. Число разделяется на две части — значащую часть (мантиссу) и степень. Например, число 123 можно записать как 2 10 23 . 1 ⋅ , число 123000 — как 5 10 23 . 1 ⋅ , число 0,123 — как 1 10 23 . 1 − ⋅ . При этом возможное количество вариантов для передаваемых 64 битами чисел резко возрастает. Правда, точность представления чисел от этого не повышается — она всегда равна номеру последнего знака мантиссы. Но так как нас практически всегда интересуют результаты ограниченной точности (чаще всего лишь до третьего знака после запятой), то модель чисел с плавающей точкой вполне приемлема.

В общем случае число имеет форму , 2e m s ⋅ ⋅ где s — знак числа (1 бит), т — целое число, определяющее мантиссу (под него отведено 53 бита), е — показатель степени (10 бит) от -1074 до 971.

Проанализируем приведенные цифры.


Если значимая часть числа может определяться 53 двоичными разрядами, то количество его десятичных разрядов не может превышать . 15 ) 2 lg( 15 ≈ ⋅ Это означает, что точность вычислений ограничена 15 действительными знаками. Если длина мантиссы поступившего на обработку числа превышает 15 знаков, то оно просто округляется:

trace (1.555555555555557); // Выводит: 1.55555555555556

Если целое число образовано более чем 15 цифрами, то также производится округление до 15 значащих разрядов. Мантисса при этом будет записана в виде десятичной дроби, а порядок вынесен в инженерном формате:

trace (1234568901234567890); // Выводит: 1.2345679Э012346е+19

Аналогичным образом преобразуются и дробные числа:

trace (0.0000001234567890123956789) ; // Выводит : 1.23456789012346е-7

То, что на хранение показателя степени числа с плавающей точкой выделяется ограниченное число бит, означает, что невозможно работать с очень большими или очень малыми значениями.

Максимальное число, которое может участвовать в вычислениях, называется машинной бесконечностью. Определить его, даже не прибегая к встроенным константам, очень просто. Исходя из описанных принципов представления чисел с плавающей точкой, очевидно, что оно должно иметь максимально возможную мантиссу, умноженную на максимально возможную степень, В двоичном представлении это будет число, действительная часть которого образована 53 единицами, а порядок равен 2 в степени 971. Попробуем определить десятичное значение этого числа:

var n = 0;
// Цикл определяет сумму
// 252 + 251 +250 +249 +...+21 +20 - максимальное значение мантиссы
for (i=0; i<53; i++) {
n += Math.pow (2, i);
}
// Умножаем максимальную мантиссу на максимальную степень.
trace (n*Math.pow(2, 971)); // Выводит: 1 .797б9313486231е+308

Полученная величина и является приблизительным значением искомой машинной бесконечности. Для ее обозначения в ActionScript используется специальная константа Infinity. Если окажется, что поступившее на обработку число превышает (по абсолютной величине) машинную бесконечность, то оно будет заменено им:

trace (1e+400); // Выводит: Infinity

Значение Infinity достаточно часто возвращается при расчетах. Наиболее очевидный случай — это деление на нуль:

trace(-1/0); // Выводит: -infinity (бесконечность может быть отрицательной)

Слово Infinity воспринимается интерпретатором как соответствующее числовое значение. Поэтому вы можете использовать его в расчетах точно так же, как и обычные числа:

trace (1/Infinity); // Выводит: 0
trace (Infinity*O); // Выводит: NaN (такое произведение не определено)

Иногда бывает необходимо определить, является ли число конечным. Это следует делать тогда, когда поступление в качестве аргумента бесконечности может вызвать сбой или неопределенность (например, синус от Infinity не имеет конечного значения). Разрешить эту задачу можно двояко.

Во-первых, можно просто сравнить поступившее на обработку значение с Infinity:

var value = Infinity;
if (value = Infinity) {
trace("Недопустимее значение"); // Выводит: Недопустимое значение
}

Во-вторых, можно воспользоваться специальной глобальной функцией isFinite(). Эта функция возвращает true, если переданное ей число конечно, и false, если оно равно бесконечности. Недостатком данной функции является то, что значение false она возвращает и тогда, когда аргумент чис-лом не является.

var value = infinity;
if (isFinite(value) =false) {
trace("Недопустимое значение") // Выводит: Недопустимое значение
}

Ограничение имеется не только для положительных значений показателя степени числа с плавающей точкой, но и для отрицательных. Это означает, что существует число, все числа меньше которого воспринимаются как 0. Это число называется машинным нулем и равно 324 1024 10 1247 9406564584 . 4 2 1 − − ⋅ ≈ ⋅ :

trace (1e-400); // Выводит 0

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

var a=50O000;
var expr1=a/(Math.pow(а+1,1/2)+Math.pow(а,1/2));
var expr2=a*(Math.pow(а+1,1/2)-Math.pow{а,1/2));
trace (expr1-expr2); // Выводит: 3.72591557606938е-9

Результаты расчетов по двум идентичным формулам различаются, пусть и не значительно. А это означает, что если бы мы пытались установить факт равенства этих выражений, используя предложение if(), то вывод был бы сделан неверно, что связано с тем, что в ActionScript два числа равны только тогда, когда равенство соблюдается для всех разрядов.

Причиной появления ошибок, подобных описанной, является то, что числа сохраняются с ограниченной точностью. Конечно, 15 знаков мантиссы достаточно для большинства расчетов. Но в некоторых случаях ошибки округления способны накапливаться, искажая результат весьма значительно. Особый случай представляют встроенные тригонометрические функции, результаты вычислений значений которых в точках нулей и разрывов практически никогда не совпадают с математически верными:

trace (Math,sin(Math.PI)); // Выводит: 1.22460635382238е-16 (нужно -0)
trace (Math.tan(Math.PI/2)); // Выводит: 1.63317787283838е+16 (нужно –
// Infinity)

Причиной появления не совсем правильных результатов в приведенных примерах является округление мантиссы чисел до 15 знаков. Справиться с этой проблемой непосредственным образом невозможно. Однако если в вашем сценарии будут сравниваться получаемые по формулам величины, то избежать появления ошибок все же реально. Для этого значения нужно округлить до того разряда, который является для вас значимым. Сделать это можно, используя метод Math.round(), о котором мы поговорим, когда будем обсуждать объект Math.

Иногда при расчетах возникает ситуация неопределенности. Например, не существует соотношения 0/0, невозможно умножить число на строку или вычислить корень из отрицательного числа.

Для того чтобы система могла реагировать на такого рода ситуации, в нее была введена специальная величина NaN (сокращение от Not a Number):

trace(0/0); // Выводит: NaN
trace(4*"Четыре"); // Выводит: NaN
trace(Math.log(-6)); // Выводит: NaN

Так как NaN, в отличие от Infinity, не имеет конкретного числового значения, то определить, имеет ли поступившее на обработку число конечную величину, просто сравнив его с NaN, невозможно:

trace(NaN==NaN); // Выводит false (то есть NaN не равно NaN)

Выяснить, принадлежит ли некоторая величина к категории Not-a-Number, можно, воспользовавшись специальной функцией isNaN(). Данная функция возвращает true, если переданное ей значение является NaN, и false, если это число. Если в качестве аргумента используется строка или другой нечисловой тип данных, то isNaN() возвращает true.

trace (isNaN("Строка")); // Выводит: true
trace (isNaN(0/0)); // Выводит: true
trace (isNaN(56)); // Выводит: false

Функция isNaN() может быть весьма полезна — во избежание ошибочных ситуаций, связанных с поступлением на обработку величин недопустимых типов.

Операции с числами
Арифметические операции с числами в ActionScript проводятся по стандартным правилам. Поэтому специально описывать этот вопрос не имеет смысла. Единственное, что нужно запомнить, так это то, что помимо стандартных арифметических операторов существуют и особые операторы, совмещающие присваивание и модификацию исходного значения левого операнда. К ним относятся:

var t=10;
t += 2; // Оператор прибавляет величину к значению переменной
t -= 2; // Оператор отнимает величину от значения переменной
t *= 2; // Оператор умножает значение переменной на величину
t /= 2; // Оператор делит значение переменной на величину
t++; // Оператор инкрементирования; прибавляет к значению переменной
t--; // Оператор декрементирования: отнимает от значения переменной

Достаточно необычным арифметическим оператором является %, вычисляющий остаток от деления одной величины на другую:

trace(14 %3); // Выводит: 2 (14=3*4+2)

Для более сложных, чем арифметические преобразования, операций с числами существуют методы объекта Math(). В этих методах сохранены наиболее часто используемые математические функции. Также объект Math имеет набор свойств, хранящих основные математические константы.

Класс Number — методы и свойства
Помимо типа number в ActionScript существует класс Number. Он не имеет большого практического значения и введен для соответствия ActionScript стандарту ECMAScript. Хотя при помощи конструктора этого класса можно создавать числа-объекты, делать это вряд ли имеет смысл. Класс Number() если и может быть интересен, то только своими методами и свойствами, позволяющими упростить некоторые операции с числами.

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

var numb1 = new Number(1);
var numb2 = new Number ("0xff") ,-
var numb3 = new Number(true);
trace(numb1); // Возвращает 1 (число преобразуется в число)
trace(numb2); // Возвращает 255 (строка преобразуется в число, если
// соблюден формат числа)
trace(numb3); // Возвращает 1 (true — логическая единица)

Числа, созданные при помощи конструктора Number(), в отличие от «обычных» чисел, будут относиться не к типу number, а к типу object:

var num_simple=3;
var num_obj=new Number(3);
trace(typeof(num_sinple)); // Выводит: number
trace(typeof(num_obj)); // Выводит: object

Впрочем, никаких различий между тем, как осуществляются математические операции над числами, созданными разными способами, не существует:

trace (num_simple-num_obj); // Выводит: 0
trace (Math.pow(num_obj,2)); // Выводит: 9

Разница между числами типа number и «числами» типа object заключается в том, что последние обладают наиболее общими возможностями объектов. Так, например, вы можете добавить к числу-объекту свойство или метод:

var new_num_simple=6;
var new_num=new Number(6);
new_num.factoria1=720;
new_num_simple.factoria1=720;
trace(new num simple. factorial)
// Выводит: undefined (добавить
// свойство к числу нельзя)
trace(new num.factorial);
// Выводит: 720 (любой объект
// может иметь свойства)

Создание объектов класса Number имеет скорее теоретическую, нежели практическую важность.

Гораздо чаше функция Number() используется как глобальная функция, служащая для приведения объектов различных типов данных к числовому, чем как конструктор класса.

trace ("12"+"34"); // Выводит: 1234 (при сложении строки сливаются)
trace (Number("12")+Number("34")); // Выводит: 46 (строки предварительно
// были переведены в числа)

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

Важнейшим среди встроенных элементов класса Number является метод toString(), который позволяет переводить числа в строковое представление. Это нужно, например, чтобы трассировать шестнадцатеричный код цвета (иначе он будет переведен в десятичный формат) или чтобы представить результат с незначащими нулями (что порой необходимо, чтобы показать его точность). В качестве параметра метод toString() принимает основание системы счисления, в которой должно быть отображено число. Это должно быть целое число от 2 до 32 (кроме 10). Если параметр отсутствует, то число переводится в строку в десятичном формате.

var new_color=0xFFFFFF;
trace(new_color); // Выводит 16777215 (число приведено к основанию 10)
trace(new_color.toString (16)); // Выводит: ffffff (шестнадцатеричный
// формат сохранен)
trace(new_color.toString()); // Выводит: 16777215 (по умолчанию
// используется основание 10)
trace(new_color.toString*2)); // Выводит: 111111111111111111111111
// (двоичное число)
trace(new_color.toString (29)); // Выводит: nkq3j (использована 29-ная (!)
// система счисления)

Обратите внимание, что для того, чтобы применить к числу метод класса Number, оно совсем не обязательно должно быть объектом этого класса. Метод toString() отлично работает и в случае простых чисел.

Второй из двух существующих методов класса Number(), valueOf(). служит для конвертирования объектов этого класса в элементарный тип number. Практического значения данный метод не имеет, поэтому подробно рассматривать его мы не будем.

Класс Number имеет и несколько встроенных свойств. Предназначены они для хранения важнейших числовых констант, таких как бесконечность, максимальное и минимальное допустимые числа, NaN. Так как со всеми этими значениями мы уже сталкивались, просто перечислим соответствующие им свойства:

Number.MAX_VALUE // Максимальное допустимое число (1.79769313486231е+308)
Number.MIN_VALUE // Минимальное допустимое число (4.940656458412476-324)
Number.NEGATIVE__INFINITY // ∞ − (возвращает -Infinity)
Number.POSITIVE_INFINITY // ∞ + (возвращает +Infinity)
Number.NaN // Недопустимое числовое значение" (возвращает NaN)

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

/* Метод класса — это функция, сохраненная в прототипе его конструктора. При этом она автоматически попадает в цепочку наследования каждого из объектов этого класса, "Адресом" прототипа конструктора класса Number будет "Number.prototype". Создаваемый метод назовем factorial.*/

Number.prototype.factorial = function() {
/*

Перед тем как запустить механизм, вычисляющий факториал, необходимо проверить, корректно ли вызвавшее метод число в рамках данной задачи. Оно должно иметь конечное значение (а не NaN или Infinity), быть неотрицательным и целым. Последнее условие можно проверить, отняв от аргумента результат его округления методом Math.round{).

Если число - целое, то округленное значение совпадет с исходным, и, следовательно, их разность будет равна 0. В качестве аргумента нужно использовать ключевое слово this:

оно укажет на тот объект, который вызвал метод. */
if (isNaN(this) == false && isFinite (this)==true && this>=0 &&
this-Math.round(this) = 0) {
/*

Если прописанные ограничения на величину числа будут выполнены, то вычисляем факториал. Для этого запускаем цикл по целочисленной переменной от 1 до this (число, вызвавшее метод), и на каждой его итерации домножаем предыдущее значение переменкой factor на нее. Начальной величиной factor должна быть 1. */

var factor = 1,
for (var i = 1; i<=this; i++) {
factor *= i;
}
// Возвращаем значение факториала при помощи предложения return
return factor;
}
/* Если окажется, что вызвавшее метод число имеет недопустимое значение, необходимо
возвратить значение NaN*/
else {
return NaN;
}
};
var a=0, b=5, c=3;
trace (a.factorial()); // Выводит: 1
trace (b.factorial()); // Выводит: 120
trace (с.factorial()); // Выводит: NaN

Как видите, созданный нами метод работает точно так же, как если бы он был встроенным методом ActionScript. Использование возможностей объектной модели ActionScript позволяет решать многие задачи куда изящнее, чем с применением только «простого программирования.

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

Пример:

trace ((1000).toString(16)); // Выводит: 3e8

Преобразование строк в числа. Функции parseInt() и parseFloat()
Хранение числовых значений в строках — это весьма распространенный на практике прием. Например, таким образом можно отображать величины, представленные в других системах счисления. Так, код цвета гораздо удобнее сохранять в шестнадцатеричном формате, чем десятичном.

Если же работать с ним как с числом, то и в панели Output, и в текстовых полях будет отображаться исключительно его десятичное значение. Переведя же код в строку, можно вывести его в нужном формате. Особое значение сохранение числовой информации в строках имеет для передачи данных в сети.

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

Строка не должна содержать никаких символов, кроме цифр, + или - для обозначения знака числа или знака степени, буквы е для введения степени. Число должно быть представлено в десятичном формате.

trace (Number("-454e+5")); // Выводит: -45400000 (правильный
// формат строки)
trace (Number("FFFF00")); // Выводит: NaN (функция не распознает
// шестнадцатеричных чисел)

• Перед числом в строке могут быть пробелы и ведущие нули. Последнее утверждение, правда, справедливо лишь в том случае, если число содержит цифры 8 или 9. Иначе оно будет интерпретировано как восьмеричное.

trace(Number("00067")); // Выводит: 55 (число было распознано как
// восьмеричное)
trace(Number("000678")); // Выводит: 678 (наличие цифры 8 указывает
// на десятичный формат)

• Строки с шестнадцатеричными и восьмеричными величинами должны начинаться с приставок, соответственно Ох и 0.

trace(Number("0x99FA")); // Выводит: 39418 (использована
// корректная запись)
trace(Number("99FA")); // Выводит: NaN (отсутствует "0х" -
// шестнадцатеричный формат не распознан)

Помимо функции Number() в ActionScript существуют и куда более мощные возможности по преобразованию строк в числа. Их носителем являются глобальные функции parseInt() и parseFloat().

Функция parseInt(string, radix) служит для выделения целого числа из строки. Она принимает два параметра; string — преобразуемая строка, radix — число от 2 до 32, указывающее интерпретатору, в какой системе счисления определено выделяемое значение (если оно не задано, то по умолчанию используется десятичное основание).trace(parseInt ("10101101",2); // Выводит: 173 (двоичная система счисления) trace(parseInt ("10101101")); // Выводит: 10101101 (десятичная система // счисления)
Функция parseInt() способна выделять целое число из строки, даже если в ней содержатся знаки, не являющиеся цифрами, символами + и - и указателем на степень. В этом случае в число конвертируется последовательность символов до первого недопустимого знака. Если же буква или оператор начинают строку, то функция возвращает NaN.

trace(parseInt("2747464 - мой телефон")); // Выводит: 2747464 (число
// стоит в начале строки)
trace(parseInt("Мой телефон - 2747464")); // Выводит: NaN (строка
// начинается с буквы)

В строке перед подлежащим выделению числом могут располагаться пробелы и ведущие нули.

Однако нужно учитывать, что если параметр системы счисления опущен, то нуль перед числом будет интерпретирован как префикс восьмеричной системы. Также функция parseInt() способна распознавать приставку шестнадцатеричного числа Ох.

trace (parseInt("000123")); // Выводит: 83 (интерпретировано как
// восьмеричное)
trace (parseInt("000123",10)); // Выводит: 123 (основание указано явно,
// поэтому ведущие нули игнорируются)
trace(parseInt("0xFFAA")); // Выводит: 65450 ("0х" указывает
// на шестнадцатеричное основание)

Очень схожей с parseInt() является функция parse Float(), предназначенная для выделения из строки числа в формате с плавающей точкой. Функция parseFloat() принимает только один параметр — строку, числовое значение в которой должно быть задано в десятичном формате.

trace (parseFloat("3.456е+7")); // Выводит: 34560000
trace (parseFloat(" -034АВС")); // Выводит: 34 (ведущие нули и
// пробелы игнорируются)

Среди описанных функций особенно ценна parseInt(), так как, используя ее, возможно преобразовывать значения произвольных систем счисления в десятичные числа.

Оцените статью: (0 голосов)
0 5 0

Статьи из раздела Action Script на эту тему:
Клипы (тип movieclip)
Кодировка символов. Уникод во Flash
Основные понятия
Синтаксис ActionScript
Тип undefined