Добрый день, сегодня без вступления. Почти

Функции
Если задуматься, что же такое функция, то можно понять, что это набор каких-то команд, который помещен в какую-то оболочку с названием. Что-то типа ребенка, которого вы научили выносить мусор. Вы вызываете у него функцию и он начинает выносить мусор. Если бы он не был научен и не знал набор инструкций, то вам бы пришлось каждый раз проводить его до мусорного бака, показывать куда выкидывать пакет, и как скрываться с места происшествия. То есть, как можно заметить, функция сокращает время и помогает мыслить более масштабно, используя (детишек!) уже более хитрые шаблоны достижения вашей цели. Давайте посмотрим, о чем я говорю. Представим, что вы внезапно захотели украсить свои математические и строковые тренировки разделителями с завитушками, ну примерно так (это означает, что вам сейчас опять придется открыть Main.as, удалить ваши предыдущие старания и написать вместо них следующие строки):

var x: Number = 20;
var y: Number = 10;
var z: Number = 30;
var text: String;

text = 'x=' + x + ', y=' + y + ', z=' + z;

trace(' ____________________________');
trace('/                            \\');
trace('------------------------------');
trace('/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\');
trace(text);
trace('\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/');
trace('------------------------------');
trace('\\____________________________/');

Как видите, такой чизбургер занимает 8 строк кода, но на что не пойдешь ради завитушек! Итак, вы подумали, что можно проделать с вашими числами еще что-то. Например, вывести, сколько будет z * x, или x — y. И все в своем чизбургере, разумеется:

var x: Number = 20;
var y: Number = 10;
var z: Number = 30;
var text: String;
text = 'x=' + x + ', y=' + y + ', z=' + z;

trace(' ____________________________');
trace('/                            \\');
trace('------------------------------');
trace('/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\');
trace(text);
trace('\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/');
trace('------------------------------');
trace('\\____________________________/');

text = 'z * x = ' + (z * x);

trace(' ____________________________');
trace('/                            \\');
trace('------------------------------');
trace('/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\');
trace(text);
trace('\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/');
trace('------------------------------');
trace('\\____________________________/');

text = 'x - y = ' + (x - y);

trace(' ____________________________');
trace('/                            \\');
trace('------------------------------');
trace('/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\');
trace(text);
trace('\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/');
trace('------------------------------');
trace('\\____________________________/');

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

function cheeseburger() : void
{

}

Перед вами пустая функция с именем cheese­burger. Она полна таинства и увлекательности. Попробуем рассмотреть каждое слово и заодно символ. Первым в этой вещи идет слово func­tion, оно почти как “var”, но только тут объявляется не переменная, а функция, которая сразу же несет в себе какое-то действие, в отличие от var, где можно объявить переменную, но ничего с ней не делать, а потом изменить. С функцией такого не прокатит. Следующим после слова func­tion идет название самой функции, в нашем случае это cheese­burger. Затем идут открывающие и закрывающие скобки. Там идут входящие параметры, которые могут использоваться внутри функции, но если их нет, то можно и не писать. О них будет чуть позже, чтоб не нагружать вас сразу же. Далее идет двоеточие (прямо как в объявлении переменной), а после него идет тип функции. Как бы это не было странно, но у функции есть тоже тип. Только у функции это тип значения, которое вернет эта функция. Об этом будет тоже позже, чтоб вас не травмировать. Void обозначает, что функция ничего не возвращает, если что. Затем мы видим открывающую фигурную скобку, это обозначает, что после этой скобки вы можете писать всяческий код, который будет храниться в этой функции. Закрывающая скобка обозначает, как вы понимаете, окончание функции. Но спешу заметить, что тут существует иерархия фигурных скобок. То есть вы можете вложить в функцию еще одну функцию, но в таком случае, у нашей функции cheeseburger, окончанием будет уже вторая закрывающая фигурная скобка (потому что первая закрывающая скобка будет служить окончанием вложенной функции. Трудно понять, наверное, но на деле, если привыкнуть, все будет гораздо проще). Итак, мы разобрали нашу функцию по кусочкам и стоит закрепить витающие знания делом. Напишем в нашу функцию весь тот завитушечный сброд:

function cheeseburger() : void
{
trace(' ____________________________');
trace('/                            \\');
trace('------------------------------');
trace('/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\');
trace(text);
trace('\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/');
trace('------------------------------');
trace('\\____________________________/');
}

Когда вы пишете что-то в функции, то обычно код в ней автоматически табулируется на одну табуляцию вправо. Такой подход помогает понять, что вы находитесь на каком-то уровне вложенности во что-то. Выглядит приятно, молодежно и стильно. Давайте теперь перепишем наш код по новой:

var x: Number = 20;
var y: Number = 10;
var z: Number = 30;
var text: String;

function cheeseburger() : void
{
trace(' ____________________________');
trace('/                            \\');
trace('------------------------------');
trace('/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\');
trace(text);
trace('\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/');
trace('------------------------------');
trace('\\____________________________/');
}

text = 'x=' + x + ', y=' + y + ', z=' + z;
cheeseburger(); // мы вызвали функцию "чизбургер!".
// Очень схоже на trace(), не так ли? Так что же такое trace, в таком случае, ммм?

text = 'z * x = ' + (z * x);
cheeseburger();

text = 'x - y = ' + (x - y);
cheeseburger();

Как видите, теперь это коротко и ясно все, и занимает в 8 раз меньше места. Но внезапно нам захотелось выводить не только переменную text (она ведь у нас в функции cheese­burger трейсится) в завитушках, но и другие какие-нибудь вещи, например просто себе привет передать. Что для этого вы предпримете? Вполне может быть, разбили бы функцию на “верхняячасть чизбургера” и на “нижняя часть чизбургера”, и затем вызывали бы сначала верхнюю часть чизбургера, затем выводили бы ваше послание, а затем вызывали бы нижнюю часть чизбургера. Но это не торт, согласитесь. Давайте еще раз прочитаем строки, где говорилось о каких-то входящих параметрах. Так вот, у функции есть входящие параметры. Ей их можно создавать, если они необходимы, а можно и не создавать, если функция самодостаточна и ей никто не нужен. У нас функция была самодостаточной, пока нам внезапно не взбрело в голову что-то выводить еще там другое. Давайте же разбираться с входящими параметрами

Параметры у функции
Стоит вам рассказать об этом. У функции существуют входящие параметры. Они бываю двух типов: обязательные и необязательные. Что это такое? Сейчас объясню. Возьмем в пример функцию say­Hello, и функцию sayHelloTo. Они будут выглядеть так:

function sayHello(name: String = '') : void
{
	trace('Привет ' + name);
}

function sayHelloTo(name: String) : void
{
	trace('Привет, ' + name);
}

Для начала стоит глянуть на то, что в скобках появились переменные какие-то. Это и есть входящие параметры. То есть, вызывая функцию, мы теперь можем указать ей какой-то параметр (в нашем случае, это строка), ну, типа sayHello(“Петька”);. Как можно заметить, эта переменная используется внутри функции, но хочу так же заявить, что дальше этой функции переменную использовать будет нельзя. В смысле, внутри этой функции переменная существует, но как функция выполнится, переменная исчезнет. Навсегда. Это еще называется локальной переменной, вот такие дела (по секрету, мы сейчас все в наших трудах пишем с помощью локальных переменных, и вы не поверите, но даже функции в данный момент локальные пишем (пока что), но это так, отступление). А теперь вам мимолетное задание: определить, в какой из этих двух функций используется обязательный параметр. Ответ строкой ниже

Правильный ответ: во второй. Во второй функции используется обязательный параметр. Объясняется это тем, что у нее параметр просто типа String, а в первом варианте он еще и автоматом заполняется (пустой строкой (две одинарные кавычки), но все же определен параметр). Итак, определительная черта обязательного параметра от необязательного в том, что обязательный параметр просто объявляется, а необязательный параметр объявляется, но еще и к нему вдобавок сразу же идет присвоение какого-то значения. Теперь стоит объяснить, в чем соль необязательных и обязательных параметров. Вы, скорее всего, и так уже догадываетесь, ведь вы и сами в жизни говорили не раз слово “не обязательно”. То есть, можно вписать, если хочется, а можно и оставить как есть. В этом-то и все отличие. Необязательный параметр обозначает, что обычно он используется почти всегда вот в таком варианте, но если надо, то все можно поменять. Так же хочу заметить, что если создать несколько параметров в одной функции, обязательных и не очень, то обязательные параметры должны идти в первую очередь, а после них, вконце, уже необязательные, иначе вас ждет ошибка. Вот, проверьте:

function getBall(type: String = 'футбольный', size: Number) : void
{

}

Вы получите такую ошибку: Error: Required para­me­ters are not per­mit­ted after optional para­me­ters.. Если же не вписать в функцию параметр, хотя он обязательный, вы получите такую ошибку: Error #1063: Несоответствие количества аргументов в Function/Main/private:init/getBall(). Ожидалось 1, получено 0.. То есть, оно ожидало параметр, а я обломал его, но за это и поплатился. Запомните эти ошибки, быстрее сможете понять, в чем проблема.

Наверное, вы уже и забыли, к чему я это все клоню, а клоню я к нашим старым добрым завитушкам. Давайте добавим в наш чизбургер обязательный параметр “stuffing” (вроде как начинкой переводится :), которую и будем высвечивать:

var x: Number = 20;
var y: Number = 10;
var z: Number = 30;
var text: String;

function cheeseburger(stuffing: String) : void
{
	trace(' ____________________________');
	trace('/                            \\');
	trace('------------------------------');
	trace('/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\');
	trace(stuffing);
	trace('\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/');
	trace('------------------------------');
	trace('\\____________________________/');
}

text = 'x=' + x + ', y=' + y + ', z=' + z;
cheeseburger(text);

text = 'z * x = ' + (z * x);
cheeseburger('Невероятно, но факт: ' + text);

Как видите, это более приятно. Давайте попробуем теперь еще возвращать значение. Забудем о чизбургере, он умер. Теперь мы математики. И нам внезапно стало интересно, а что будет, если взять число (какое на ум пришло), прибавить к нему двойку, а затем умножить результат на 2, а затем прибавить тройку, а затем отнять задуманное число, а затем прибавить пятерку, а затем отнять тройку. Что же получится из этого? Поэтому вооружившись мелом и клавиатурой, мы решаем узнать наш мучающий нас вопрос (а заодно удалите все ваши предыдущие старания):

// мы будем работать только с целыми числами, поэтому
// и входящие и выходящие параметры будут целыми числами
// заметьте, что уже не void, а int на выходе

function solveProblem(num: int) : int
{
	var result: int;
	result = num + 2;
	result = result * 2;
	result += 3; // чтоб не писать result = result + 3
	result -= num; // аналогично
	result += 5;
	result -= num;

	return result; // внезапно какой-то return. Если перевести
	// это слово на русский, то снанет понятно, что функция вернет
	// куда-то наш результат. return используется для выхода из функции
	// попутно возвращая какое-то значение. Для функций, что возвращают
	// void, не нужно указывать, что возвращать, произойдет просто выход из функции
}

var num1: int = solveProblem(240);
var num2: int = solveProblem(1);
var num3: int = solveProblem(4);

trace(num1, num2, num3);

Мы получили ответы на интересующие нас вопросы: всегда выходит 12. Это все потому, что это математический фокус-покус *хохочет до слез*

Также, для пытливых умов, коорые “а как это так в трейс вмещаеся миллион переменных, хотя в подсказке видно только одну входящую переменную?”. Я вам скажу, это все из-за секретной комбинации “…rest”. Вернее, вообще троеточие перед названием переменной (в данном случае это rest). Но так как это массив, о котором в данной статье речи не пойдет, разбирайтесь сами, вот

Условия
Если можно подумать, что краткий экскурс в функции введен, то в условия не введен, что сейчас и будет исправляться. У меня есть подозрение, что вы уже подозреваете, что такое условие. “Не идешь со мной? Тогда я сам пошел”. Вот тут ставится условие, и еще и выполняется оно. Рассмотрим же, как это выглядит во флеше:

if(24 > 3)
{
	trace('24 > 3');
}

Итак, что мы видим? На первой строчке пишется условие “if” и в скобках само условие (24 > 3). Затем выполняется (да-да, не зря я первым делом начал рассказывать про функции) что-то типа функции. Все ровно так же: открывающая скобка, закрывающая скобка. Как же это будет выглядеть “по-нашему”? Как-то типа этого:

если(24 > 3)
выполнить следующее
	trace('24 > 3');
закончить выполнять

Также в условиях есть еще некое “а если нет, то тогда выполнить следующее”. Называется оно else

if(2 > 4)
{
	trace('два больше четырех');
}
else
{
	trace('два меньше четырех!');
}

При написании такой конструкции, мы увидим сообщение, что два меньше четырех, и это удивительно! Также существует еще else if. Это когда “если в магазине не будет белого хлеба, купи черный, если не будет и черного хлеба, тогда купи булочку, если даже булочки не будет, купи бублик, ну если даже бублика не будет, то выйди с казино/стрипклуба/кинотеатра и зайди в магазин”. Выглядит это так:

if(1 > 3)
{
	trace('1 > 3');
}
else if (2 > 3)
{
	trace('2 > 3');
}
else if (3 > 3)
{
	trace('3 > 3');
}
else if (4 > 3)
{
	trace('4 > 3');
}

Если порассуждать, то выполнится только последнее условие (и так и есть!). Если же вы, например, во втором условии “2 > 3″ двойку поменяете, например, на пятерку, то после того, как выполнится второе условие, проверяться третье и четвертое не будут. Какие же основные операторы сравнения? Сейчас расскажу самые основные:

>    - больше (4 > 1)
<    - меньше (1 < 4)
==  - приравнивается (4 == 4)
>=  - больше или равно (4 >= 4)
<=  - меньше или равно (4 <= 4)

Запомните, что в условиях вы сравниваете числа только с помощью двух знаков равенства, если поставите один, вы произведете присваивание, чему мы учились в предыдущих статьях. Нельзя сравнивать, в общем, таким образом: “if(a=b)…”, нужно “if(a==b)…”

И да ИЛИ
Так как оператором “>=” было затронуто слово “ИЛИ”, то стоит вам рассказать о таких понятиях, как И и ИЛИ. И и ИЛИ это еще одни дополнительные возможности при выполнении условий. В фразе “больше ИЛИ равно” видно, что посиживает некая ИЛИ. Пишется она так: “||”. И же пишется так: “&&”. Что нам это дает? Дает нам это новый уровень “гибкости” при выполнении условий. Например если четыре больше двух и одновременно с этим меньше шести, то выполнить условие. Или же если два меньше четырех или два больше одного, то выполнить условие

var a: Number = 2;
var b: Number = 4;
var c: Number = 1;
if(a > b || a > c)
{
	trace('"a" победила!');
}

if(a > b && a > c)
{
	trace('"a" тотально победила!');
}

Если вы проверите, то выполнится только первое условие, потому что “2” больше только единицы, а во втором условии, требуется чтоб “a” была больше и “b” и “c”, но так как “b” равно четырем, то второе условие обломалось. Запомните или просто усвойте, а потом сами вспомните, когда пригодится это дело

Булево число

Что касается работы условий, то есть еще один секрет: они работают не за счет этих значков (утрировано), а за счет того, что выдают они — true или false. Условие выполняется, если выражение с этими операторами выдаст true, либо не выполняется, если выдаст false. Попробуйте, напишите в трейсе что-то типа

trace((1 > 4), (2 < 6), (6 >= 6));

Вы увидите false true true. А все потому, что единица меньше четырех, двойка меньше шести, а шесть равно или меньше шести. Как говорится, добро пожаловать в число Буля. Число буля крайне многогранно: либо 0, либо 1. В нашем случае, 0 это false, а true это 1. Во флеше это Boolean тип:

var bool1: Boolean = true;
var bool2: Boolean = (2 > 4);
trace(bool1, bool2);
if(bool1)
{
	trace('true!');
}

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

На сим считаю статью закрытой. Краткий экскурс введен и туда и сюда. Теперь домашка:

Дано: детишки. Вам надо выяснить, кто умнее кого. Для этого я вам предлагаю создать функцию “com­pare”, у которой будут четыре входящих параметра: name1, iq1, name2, iq2. Это имена и айкью детишечек. В этой функции вы должны сравнить айкью, и вывести имя победителя или проигравшего. Внизу я приведу, как я буду вызывать функции и какие ответы ожидать:

compare("Петька", 90, "Максимка", 100); // Петька дурак
compare("Коля", 84, "Юрий", 82); // Юрий дурак
compare("Аполлоний", 100, "Афанасий", 100); // Победила дружба

Дерзайте. Спасибо за прочтение!

Вы когда-нибудь задумывались, что вы знаете о строках? Нет? Может вы и вовсе о них ничего не знаете? Давайте я вам расскажу. Присаживайтесь к костру, накалывайте на палку зефир и слушайте историю

Строки это набор символов. Длина строки где-то там ограничена, но зачастую лимит этой длины никому не нужен, потому как даже мегабайт информации копить в одной строке, это слишком жирно. Строки сложнее чисел, потому, что у строк есть много больше параметров, но об этом позже, мы пока сделаем вид, что абсолютно ничего не слышали о слове “параметры” и вспомним о нем через несколько статей с фразой “где-то это уже пролетало у меня на слуху… хмм”. Краткий ликбез по тому, что такое строки, считаю законченным: набор символов и все тут, даже если нет символов, то все равно набор из нуля символов. Давайте лучше что-нибудь напишем каверзное. Открывайте Main.as, стирайте ваши предыдущие старания с цифрами (ну или оставьте, если очень нравится вам результат), творите:

var hello: String = "Привет";
var world: String = 'мирочек';
var helloWorld: String = hello + world;
trace(helloWorld);

Смотрим, что тут произошло: во-первых, вы помните, что тип строки это String, во-вторых, тут видно, что первая строчка в двойных кавычках записана, а вторая строчка в одинарных. В-третьих, мы видим, что строки можно складывать. Но что мы видим? Я уверен, вы ожидали увидеть “Привет мирочек”, но увидели “Приветмирочек”. А все потому, что пробел это тоже символ. Давайте его добавим прямо в переменной helloWorld:

var hello: String = "Привет";
var world: String = 'мирочек';
var helloWorld: String = hello + " " + world;
trace(helloWorld);

Теперь все ок. Давайте теперь поучимся писать текст с кавычками:

var once: String = "'одинарные'";
var double: String = '"двойные"';
var multi: String = "'" + '"' + 'всякие' + '"' + "'";
trace(once, double, multi);

В первой строке мы в двойные кавычки взяли одинарные. Во второй строке мы одинарные взяли в двойные. В третьей строке мы попеременно брали в одинарные кавычки двойные, в двойных кавычках одинарные и вот так вот выкрутились из ситуации. Но я вам расскажу еще об одном чудном символе, его имя — обратный слеш. Он пишется так: “\”. Всякий раз, как в строке вы ставите обратный слеш перед каким-то символом, его (слеша, а еще и иногда символа) не будет видно. Если же это кавычка, то она не будет учитываться как закрывающая. Вот, глядите:

var slash: String = "обратный \"слэш\"";
trace(slash);

Так же есть несколько комбинаций с этим обратным слешом: \n делает перевод на новую строку (\r иногда тоже), \t делает табуляцию, а спомощью двойного обратного слеша можно написать сам слеш, вот такие дела:

trace('\\Привет\n,\tмирочек\\');

Как вы понимаете, можно складывать числа и строки:

var num1: Number = 204;
var num2: Number = 48294;
var sum: Number = num1 + num2;
var result: String = num1 + ' + ' + num2 + ' = ' + sum;
trace(result);

Мы увидим внизу “204 + 48294 = 48498″. Это ведь так мило

Также я рекомендую вам обратить внимание на код ошибки, который появляется, если вы забыли закрыть скобку или что-то в этом роде со строкой:

Error: Syntax error: A string literal must be terminated before the line break.

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

У лукоморья дуб зелёный;
Златая цепь на дубе том:
И днём и ночью кот учёный
Всё ходит по цепи кругом;

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

(первый способ, это написать в одну строку, и каждый столбик разделять с помощью \n, а второй способ это 4 раза протрейсить 4 разных строчки)

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

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

1. Num­ber — это любое число, будь оно дробное или очень большое или даже минус десять. Оно останется таким. Иногда, из-за погрешностей в флеше будут изменения на одну миллионную, но на то он и флеш, чтоб не быть серьезной системой исчислений. Понимает как отрицательные, так и положительные числа
2. int — этот тип чисел предназначен только для целых чисел. Даже если вы напишете 2.5, то оно запомнит это как 2. Оно отсекает все дробное и имеет при себе только вот это. Тоже понимает отрицательные и положительные
3. uint — этот тип чисел хранит числа от нуля до 4294967295. Если задать ему 4294967296, то вы получите 0, а если задать 4294967297, то получите 1. То есть, как вы можете догадаться, идет по кругу. Также uint не может быть отрицательным, то есть число –1 будет равно 4294967295. Так же число 4294967295 можно запомнить как 0xFFFFFFFF (4 пары F. Это шестнадцатибитное исчисление, и в uint первые две F обозначают прозрачность, а остальные 6 F обозначают кодировку цвета, но об этом опять же позже. Просто знайте об этом)

Мы в основном будем почти всегда использовать один лишь Num­ber, но временами будут случаи, когда лучше воспользоваться int или uint в целях более быстрой работы или более упорядоченной мысли. Давайте вспомним, как объявляется переменная и как она меняется:

var myNumber: Number = 24;
myNumber = 16;

Итак: слово “var” это начало объявление переменной, “myNum­ber” — это то, как мы назвали переменную. Воля фантазии должна помочь вам выдумать название для переменной, только с одним условием: в них не должно быть ничего, кроме букв и цифр, причем не должно начинаться с цифр, иначе рискуете получить ошибку с названием “Error: Syn­tax error: expect­ing iden­ti­fier before #.”, где вместо “#” будет цифра, которую вы надумали поставить первой. Двоеточие после вашего названия означает, что сейчас вы укажете тип переменной, и это, как вы поняли, Num­ber. Знак равенства обозначает, что вы приравняли переменной что-то, и это в нашем случае 24. Точка с запятой обозначает, что вы закончили свою мысль. Во второй строке все и так понятно. Давайте испытаем это на деле. Откройте ваш флешдевелоп, в нем по идее открыт Main.as с вашей строчкой “trace(“Привет, безумный мир!”);”, которую я предлагаю вам удалить, и написать вместо нее вот что:

var num1: Number = 10;
var num2: Number = 5;
var sum: Number = num1 + num2;

Что же тут произошло? В первой строчке произошло создание переменной с именем num1 и равным десяти, во второй аналогично, но num2 и равное пяти, а в третей строчке переменная sum равна сумме num1 и num2. Но как узнать, чему равно sum? Сейчас вы узнаете о магическом трейсе

trace | debug
Итак, trace(он же трэйс, но из-за лени писать букву “э” это трейс) — одна из веточек, которая вытягивает вас, когда вам важно узнать что-то, или проверить ошибку, или найти ошибку. Эта команда (она же функция) выводит в окошко исходящих сообщений все, что вы ей прикажете. Абсолютно все, если это не ломает логику и не создает ошибок в коде. Может вывести вам сумму двух чисел, а может вывести вам строку, а может вывести тип переменной, а может! А может! В общем, запомните на всю свою жизнь о трейсе, это очень полезно: trace(%вашежелание%);, где вместо %вашежелание% вы пишете то, что захотели увидеть. Давайте же теперь попробуем проверить, чему равна переменная sum:

var num1: Number = 10;
var num2: Number = 5;
var sum: Number = num1 + num2;
trace(sum);

Как видите, 10 + 5 = 15, и компьютер не соврал. Кажется, вы начинаете обрастать небольшим доверием к нему. А давайте отнимем от 10 пятерку!

var num1: Number = 10;
var num2: Number = 5;
var sum: Number = num1 + num2;
trace(sum);
var sub: Number = num1 - num2;
trace(sub);

Итого мы видим: 15, 5. 10 + 5 = 15, а 10 — 5 = 5. Все сходится. Что ж, попробуем умножать и делить?

минутка сообразительности! Попробуйте проделать умножение и деление самостоятельно, а затем сверьтесь с тем, как это написано внизу (хехехе)

var num1: Number = 10;
var num2: Number = 5;
var sum: Number = num1 + num2;
trace(sum);
var sub: Number = num1 - num2;
trace(sub);
var mult: Number = num1 * num2;
var div: Number = num1 / num2;
trace(mult, div);

С этих строк, вы наверное заметили подозрительной последнюю. Но я вам скажу: через запятую можно выводить несколько переменных или прочих вещей, запомните это. 10 + 5 = 15, 10 — 5 = 5, 10 * 5 = 50, 10 / 5 = 2. Все верно

Кажется, вы поняли всю соль, как работать с числами. Давайте теперь немного попрактикуемся с int и uint. Сотрите ваши предыдущие экзекуции и пишите следующее:

var i: int = 24.18;
var u: uint = 0.5;
trace(i, u);

И мы имеем i=24 и u=0. Это лишь подтверждает, что тут работают только целые числа, давайте дальше:

var i: int = 24.18;
var u: uint = 0.5;
trace(i, u);

u = u - 2;
i = i - 25;
trace(u, i);

Тут вы можете заметить, что переменную можно прибавлять саму к себе или самой с собой работать. Так же “u = u –2″ можно записать как “u -= 2″, это аналогично. А для “-1″ или “+1″ есть такие операторы, как “–” и “++”. Ну, типа, если i = 0, то i++ = 1, а если еще раз потом написать i++, то i будет равно двум. Надеюсь, поняли. Так же, при условии что u типа uint, и, как вы помните (а вы ведь помните?), uint не может быть отрицательным и идет по кругу. То есть 0 минус 2 будет, разумеется, 4294967294. Зато int может быть отрицательным, поэтому 24 — 25 = –1, что мы и увидели в логах

По идее, с числами вы разобрались. Домашнее задание будет таково: почитать о HEX, а так же узнать, чему будет равно 0xff; 0xabcdef; 0x123456;

Допустим, вы приблизительно поняли, как оно начинает все работать и можете встревать в это дело более углубленно, постигая уже само программирование. Стоит напомнить, что программы начинаются с левого верхнего края по правый нижний, все как у нас. Поэтому читать их можно человеческими глазами и понимать, при знании слов и трюков, тоже. Весь код в основном это условия, определения, оговоренности и обращения к прошлому или взывание к каким-то потокам мыслей\действий. Все как в человеческом разговоре. Вернее даже как в детском рисунке. Но в отличие от рисунка, который понимает только ребенок, что нарисовал его, ваше творчество должен понимать другой человек. Потому, что рано или поздно, но вам придется работать совместно с кем-то или отдавать свои исходники или читать чужие. А довольно жирный процент времени на работу с чьим-то исходником выделяется просто ради того, чтоб разобраться в чужом коде. Поэтому тут вы просто обязаны быть предсказуемым кодером. Вы ведь не станете отрицать, что предсказуемый водитель, который включил поворотник и поехал направо (а я видел противоположные случаи, и некая часть моего тела сжималась крайне крепко), это хорошо? Так же само выглядит код, в котором переменная “количествоДомов” обозначает количество домов, а не “жива ли кошка или нет”, или что эта переменная будет всегда обозначать количество домов, а не “вот тут она количество домов, а вот тут я подумал, что можно эту же переменную использовать для обозначения количества людей, живущих на Марсе, а потом опять количество домов. Так же экономнее!”. И вот за эту экономность кто-то платит часами (возможно даже вы), пытаясь разобраться в столь ухищренных трюках, которые по сути экономят десяток байтов в оперативке и пару тактов на процессоре и одну строчку кода. Когда вы будете экономить целые байты и такты, вы будете писать на ассемблере, не на флеше, уверяю. И опыта программирования у вас будет более, чем достаточно (исключаются случаи, когда необходимо сэкономить огромное пожирание памяти или 40% нагрузки на процессор убавить до 2%, убрав странные действия в вашей программе)

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

1. Переменные и их типы

Что такое переменные и зачем они? Переменная — это то, чем вы оперируете в задаче, а зачем нужны — чтоб оперировать в задаче ими, чтоб решить ее. Выглядит это словно математика. Возьмем в пример программу, в которой вы вводите два числа: количество мальчиков и девочек в классе, а она вам выдаст, сколько в процентах у вас мальчиков и девочек. То есть в программу будет заложена простая формула, по типу

мальчики = (x / (x + y)) * 100;
девочки = (y / (x + y)) * 100;

Где x — число мальчиков (к примеру, 22), а y — количество девочек (допустим, 28). Итого, мальчики = 22 / (22 + 28) * 100 = 44%, девочки 56%. В программе выглядеть будет все так же само:

процентМальчиков = (количествоМальчиков / (количествоМальчиков + количествоДевочек)) * 100;

Как видите, разницы никакой (только вместо x и y тут длинные слова, но зато понятнее стало), эту формулу комп решит и у нас в переменной “процентМальчиков” уже будет храниться процент мальчиков.

Что стоит знать о переменной? Переменная от слова “перемена” (хехехе), это обозначает, что она всегда может поменяться, ей можно задать значение или не задавать его. Так же, как в языке со строгим синтаксисом (википедируйте, но в целом это строгое соблюдение правил письма, к примеру “дом” и “Дом” — разные переменные), у всякой переменной должен быть тип. Для числа это Num­ber, int, uint и прочие, но почти всегда это Num­ber, для строки это String, для звука это Sound, для изображения это Dis­play­Ob­ject и прочее и прочее. По-нашему это как обозначение типа музыки: рок, поп или же классика. Или письма: стихи, прозы, анекдоты, романы. Мы все в своей жизни типизируем и это же перенесли в программирование. Вначале дальше Num­ber и String мы не зайдем, но потом будем даже свои типы переменных сочинять, но всему свое время. Итак, мы знаем, что у переменных должен быть тип. Теперь вы еще должны понять, что переменные должны “объявляться”. Это кажется странным, но зато это логично: вы объявляете переменную, а только потом указываете ей значение. Иначе же будет трудновато понять, это вот с этого момента начали вы создавать переменную или она еще раньше где-то фигурирует? Для этого, перед работой с переменной, люди сначала объявляют саму переменную, как бы заявляя, что теперь она существует и с ней можно работать. По правилам синтаксиса, нельзя объявить одну и ту же переменную больше одного раза. То есть, заданные рамки и ограничения лишь помогают вам. Зачастую, в коде целым блоком объявляются все переменные, а потом по другим блокам растасована работа с ними. При чтении кода это очень удобно, так как можно по названиям их понять, что в целом происходит в коде (если код писали вкладывая смысл в переменные. Мне доводилось работать с чужим кодом, в котором часть переменных была shit и bull­shit. И свой смысл они не очень отражали, было сложно разбираться). А теперь давайте посмотрим маленький пример настоящего AS3 кода:

var previousYear: Number;
var currentYear: Number = 2011;
previousYear = 2010;

Первая строчка: объявление (о чем свидетельствует слово “var”) переменной по имени pre­vi­ousYear (предыдущийГод, по-нашему), ее тип Num­ber (о чем свидетельствует двоеточие и после этого — описание типа (“Num­ber”, то есть число)). Как видите, мы просто объявили эту переменную, и теперь компьютер будет знать, что у нас существует такая переменная и ей можно что-то присвоить. Во второй строчке все то же самое, окромя двух вещей: теперь создана новая переменная по имени cur­ren­tYear (текущий год) и тут уже знак равенства показывает, что мы присвоили переменной число 2011. Третья строчка присваивает переменной pre­vi­ousYear число 2011. Разница между комбо 1–3 строчками и между 2-й строчкой отсутствует (я о том, как присваивать переменным значения). То есть и так и так будет создание и присвоение значения какой-нибудь переменной. Но первый способ годится в тех случаях, когда вам заведомо неизвестно, что же туда всунуть, а левый бред подтасовывать неинтересно и вредно. Давайте рассмотрим переменную, хранящую какое-то строковое значение (по-нашему это текст):

var boyName: String = "Борисон";
var girlName: String = "Машенька";

Как видите, все то же самое, окромя одного момента: вместо Num­ber теперь String, но это и так понятно, но что это за кавычки? А это, дорогой читатель, такой способ указывать строковые значения и попытки ими оперировать. В кавычках пишутся все строковые значения, будь то единичные кавычки или же двойные, компилятор разберется, он умный. Хотя, например, в Си (язык такой) в двойных кавычках можно писать длинный текст, а в одинарных кавычках не более одного символа, то есть “Oche bol­shoi text” можно написать, а ‘Tochno gov­oru, text bolshoi’ нельзя. Во флеше же можно и так и сяк, как вам удобно, главное не совмещать оба типа одновременно. Вернее, можно, но компилятор будет смотреть какой кавычкой открыто, и будет следить, чтоб этой же кавычкой было закрыто. То есть, строчка

var boyName: String = "Борисон';

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

var boyName: String = 'Борис "Картавый" Самолетов';

… ну или наоборот.

Существуют еще константы. Это то, что можно только один раз создать и объявить сразу же, а потом больше никогда нельзя будет поменять это. Как нельзя изменить скорость света или скорость звука в нашей атмосфере (при условии, что атмосфера никогда не изменится). Константы полезны во многих случаях (например, если вам нужно будет указать где-то скорость света хехехе), по типу, что красный цвет это FF0000 (в RGB коде), или что километр = 1000 метров. Объявляются константы не с помощью “var” а спомощью оператора “const”. А в остальном все так же

const redColor: Number = 0xFF0000;

2. Операции с переменными

Как вы наверное догадываетесь, с переменными можно делать что-то другое, кроме как задавать им значение и объявлять их. Для этого придуманы математические операции. Они вам, скорее всего, знакомы: сложение, вычитание, деление, умножение. Можно приравнивать одну переменную другой или приравнять переменной сложение двух других переменных:

var a: Number = 10;
var b: Number = 5;
var c: Number;
var sum: Number; // сложение
var sub: Number; // вычитание
var div: Number; // деление
var mult: Number; // умножение

c = a;
sum = a + b;
sub = a - b;
div = a / b;
mult = a * b;

С этих строк вы узнаете о следующем: что слеш это деление, что звездочка это умножение, а два слеша — это комментарий. Комментарий не учитывается программой, а лишь помогает программисту не забыть важный момент, который он надумал комментировать. Как видите, управление переменными это просто и понятно. Что примечательно, можно складывать строковые значения (только складывать, ни вычитать или делить или умножать нельзя). Например “Попка” плюс “дурак” будет “Попка дурак”

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