Применение функций

В этом уроке вы узнаете, как создавать и использовать функции на примере программирования "пульта дистанционного управления" для Flash-телевизора.

Что будет изучаться

В этом уроке:

Время выполнения

На выполнение этого урока требуется примерно полтора часа.

Файлы урока

Файлы-носители:

Нет

Стартовые файлы:

Lesson05/Completed/television1.fla
Lesson05/Completed/television2.fla
Lesson05/Completed/television3.fla

Законченные проекты:

television4.fla

Создание функций

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

Синтаксис 1

В первом варианте программный код выглядит так:

function myFunction (аргумент1, аргумент2, и т.д.) {
  // выполняемые действия;
}

Приведенный код представляет наиболее общий способ создания функций, именно такой синтаксис будет по большей части использоваться в этом уроке. Как видите, объявление функции начинается с ключевого слова function, за которым следует имя функции (оно может быть каким угодно, только должно соответствовать общим условиям – как имена переменных, экземпляров и т.п.). Вслед за именем функции идут круглые скобки. Их можно оставить пустыми, либо указать в них аргументы (параметры), которые будет использовать функция. Оставляя скобки пустыми, вы создаете функцию без параметров – выполнение такой функции всегда имеет один и тот же результат. Если же функция имеет аргументы, то результат ее выполнения будет зависеть от конкретной информации, которую получит функция при вызове. Такое сообщение функции информации называется передачей аргументов или параметров. Вы можете указать любое необходимое число аргументов; о том, как их использовать – чуть позже.

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

Совет Скелет функции (то есть функцию, в которую вам предстоит добавить действия) вы можете создать при помощи инструментального окна панели Действия: выберите Actions > UserDefined Functions.

Синтаксис 2

В первом варианте код таков:

myFunction = function (аргумент1, аргумент2, и т.д.) {/*действия*/};

Этот вариант можно использовать для динамического создания функции или создания своего собственного метода для объекта (об этом мы расскажем в Уроке 6 – Создание и модификация объектов). Единственное отличие от первого варианта состоит в способе присвоения функции имени: имя функции стоит первым, ему, с помощью оператора присваивания " = ", назначается функция. Этот синтаксис вы сможете использовать только при ручном вводе в окно панели Действия, когда эта панель находится в Экспертном режиме ( Expert mode ).

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

myFunction();

Когда вы вызываете функцию, Flash выполняет все действия, содержащиеся внутри этой функции. Если, к примеру, myFunction() содержит 20 действий, считайте, что все они уместились в одной этой строке скрипта.

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

myFunction(значение аргумента1, значение аргумента2);

В этом примере предполагается, что объявление функции и ее вызов находятся на одном и том же монтажном столе. Каждая функция, подобно переменным и объектам, находится на том или ином монтажном столе – а именно, на том, где она объявлена. Чтобы вызвать функцию с определенного монтажного стола, необходимо указать путь, например:

_root.clip1.clip2.myFunction();

В этом упражнении мы создадим кнопку Power на пульте дистанционного управления телевизором. Этой кнопкой – с использованием функции – будет включаться и выключаться наш Flash-телик.

Совет Вызов функции можно организовать динамически, используя значение переменной. Например, так: _root.[aVariableName]() ;. Если aVariableName имеет значение " sayHello ", то получится вызов функции _root.sayHello();.

Общая структура фильма уже создана. В слое Actions мы будем размещать большую часть наших скриптов. В слое TV имеется экземпляр фильма-символа с именем tv, на его монтажном столе – три слоя: нижний слой (называется Television) – просто графика; слой над ним (Screen) содержит экземпляр фильма-символа screen, который, в свою очередь, содержит два слоя и два кадра, графическое содержание которых представляет разные "программы", которые можно будет смотреть, переключая каналы телевизора.

На основном монтажном столе имеется еще один слой – Remote, он содержит экземпляр фильма-символа remote. В нем вы найдете слой, содержащий большую часть изображений, составляющих пульт управления, в том числе экземпляр фильма-символа light, а также слой, содержащий кнопки пульта – все они в итоге будут содержать скрипты.

tvPower = false;
function togglePower () {
  if (tvPower) {
    newChannel = 0;
    tvPower = false;
  } else {
    tvPower = true;
    newChannel = 1;
  }
  tv.screen.gotoAndStop(newChannel + 1);
  remote.light.play();
}

В первой строке скрипта создается переменная tvPower, она будет использоваться для отслеживания текущего состояния телевизора: значение true означает, что он включен, false – выключен. Изначально телевизор должен быть выключен, поэтому tvPower присваивается false. Следующие семь строк представляют собой объявление функции togglePower() – эта функция при вызове будет включать или выключать телевизор. Этой функции не передаются никакие аргументы. Поскольку скрипт находится в кадре 1, переменная tvPower получает значение false и функция togglePower() объявляется после загрузки этого кадра (то есть сразу после старта фильма).

Совет Поскольку функции должны быть объявлены до их вызова, обычно все объявления функций помещают в кадр1, чтобы затем их можно было вызвать в любой момент.

В первой части функции используется оператор if, который анализирует текущее значение tvPower. Если в момент вызова функции значение переменной tvPower равно true (ТВ включен), то ей присваивается значение false (выключено), а переменной newChannel – значение 0; в противном случае ( else ) tvPower получает значение true, а newChannel = 1. Так с помощью оператора if мы меняем значение tvPower на противоположное при каждом вызове функции, при этом изменяя еще значение переменной newChannel – после выполнения этого оператора она получает значение 0 либо 1.

Затем функция отсылает экземпляр фильма-символа screen (он находится внутри экземпляра tv ) к кадру с номером newChannel + 1. К значению newChannel непременно следует добавить единицу, ведь эта переменная у нас может принимать значение 0, а во Flash кадра 0 быть не может! В итоге эта строка функции отсылает экземпляр фильма-символа screen к кадру 1 (изображающему пустой экран телевизора) либо к кадру 2 (показывает канал 1).

Завершается функция указанием проиграть фильм-символ light на пульте управления – огонек мигнет, показывая, что кнопка была нажата.

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

on (release) {
  _root.togglePower();
}

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

Каждый раз при нажатии кнопки Power вызывается функция togglePower() и выполняются все действия, входящие в нее. Как и ожидалось, эти действия включают либо выключают телевизор.

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

Создание функции с аргументами

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

function convertToMoonWeight (myWeight) {
  weightOnMoon = myWeight/6.04;
}

Эта функция вычисляет, какой вес будет иметь какой-либо предмет на Луне; единственный параметр этой функции – myWeight (вес предмета на Земле), и он указывается при объявлении функции, как если бы это была существующая переменная.

А вот пример вызова этой функции:

convertToMoonWeight(165);

Как видите, при вызове функции ей передается (то есть указывается в скобках) некоторое значение. В данном случае это вес некоторого предмета на Земле, равный 165. Это значение на время выполнения функции присваивается параметру myWeight. Так, в результате передачи нашей функции convertToMoonWeight () значения 165, переменная внутри функции weightOnMoon получит значение 165/6.04, или 27.32.

Совет При вызове функции создается временный массив под названием arguments. Этот массив содержит все передаваемые параметры – даже если при объявлении функции вы не указали ни одного. Вот как, например, можно получить доступ к массиву arguments:

function traceNames() {
  trace("Этой функции передано " + arguments.length + " аргументов");
  trace("Значение первого аргумента: " + arguments[0]);
  trace("Значение второго аргумента: " + arguments[1]);
}
traceNames("Kelly","Hayes");

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

Этой функции передано 2 аргументов;

Значение первого аргумента: Kelly;

Значение второго аргумента: Hayes;

Возможность доступа к массиву arguments позволяет создавать функции, функциональность которых может меняться в зависимости от того, сколько параметров им передано. Подробнее о массивах вы узнаете в Уроке 7 – Работа с динамическими данными.

В этом упражнении мы запрограммируем цифровые кнопки на пульте управления, а также кнопки последовательного перебора каналов – Up и Down. Цифровые кнопки будут вызывать некую функцию, передавая ей номер канала, на который следует переключиться. Также мы слегка модифицируем функцию togglePower().

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

function changeTheChannel (newChannel) {
  if (tvPower) {
    currentChannel = newChannel;
    tv.screen.gotoAndStop(newChannel + 1);
    remote.light.play();
  }
}

Вы только что создали функцию с параметром. Она меняет канал телевизора, основываясь на полученном значении параметра ( newChannel ). Все действия, выполняемые функцией, заключены в теле оператора if, в результате чего смена канала может происходить только в том случае, если tvPower имеет значение true. Функция присваивает переменной, хранящей номер текущего канала, значение переданного параметра. Две следующие строки вам уже знакомы – они использовались в функции togglePower(), которую мы создали в предыдущем упражнении: установка кадра экземпляра фильма-символа screen (в результате чего меняется картинка на экране телевизора) и указание воспроизвести экземпляр фильма-символа light (мигает огонек на пульте управления). Давайте рассмотрим пример. Допустим, имеет место такой вызов функции:

changeTheChannel(4);

Прежде, чем что-либо сделать, функция проверит значение переменной tvPower. Если оно равно true (телевизор включен), то currentChannel получает значение 4 (что было передано функции в качестве параметра). Далее экземпляр фильма-символа screen перемещается к кадру, номер которого определяется как значение параметра плюс один (то есть 4 + 1). Таким образом, screen переходит к кадру 5.

Теперь мы можем использовать созданную функцию – ее будут вызывать цифровые кнопки на нашем пульте управления.

on (release) {
  _root.changeTheChannel(1);
}

Повторите то же самое для всех кнопок с цифрами – от 2 до 6. В каждом случае в качестве параметра указывайте номер канала, который должна включать кнопка.

Функция changeTheChannel() находится на основном монтажном столе, так что при вызове следует использовать адресацию: _root.

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

Этот кадр содержит объявление двух функций; одна из них включает и выключает телевизор, а другая меняет каналы. Но обратите внимание – программный код этих функций содержит одинаковые строки: обе функции содержат указание мигнуть лампочкой на пульте управления и переместить экземпляр фильма-символа screen к определенному кадру. Такая избыточность кода совсем ни к чему, так давайте это исправим.

function togglePower() {
  if (tvPower) {
    changeTheChannel(0);
    tvPower = false;
  } else {
    tvPower = true;
    changeTheChannel(1);
  }
}

Теперь функция togglePower() для смены канала при включении и выключении телевизора вызывает функцию changeTheChannel(). При включении TV функция changeTheChannel() вызывается со значением параметра 1. То есть каждый раз при включении устанавливается первый канал. При выключении устанавливается канал 0 (пустой экран телевизора). Итак, мы продемонстрировали, что одна функция может вызывать другую.

Примечание Обратите внимание, что в приведенном выше скрипте, в первой секции оператора if, вызов функции changeTheChannel() происходит до того, как переменной tvPower присваивается значение false. Дело в том, что функция changeTheChannel() запрограммирована нами так, что она работает только в том случае, если tvPower имеет значение true (а только в этом случае и выполняется эта секция оператора if ). Если бы мы поменяли строки и сначала присвоили tvPower значение false, вызов функции changeTheChannel(0) ни к чему не привел бы. А вот в секции else все как раз наоборот: сначала tvPower получает значение true, а потом вызывается функция. Причина та же – без этого вызов функции не будет иметь эффекта.

А теперь давайте создадим пару функций, позволяющих последовательно переключать каналы "вперед" и "назад" – для соответствующих кнопок на нашем пульте управления.

numberOfChannels = 6;

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

function channelUp () {
  if (currentChannel + 1 <= numberOfChannels) {
    changeTheChannel(currentChannel + 1);
  }
}

Эта функция (она не имеет параметров) каждый раз, когда ее вызывают, переключает канал на следующий. Однако здесь имеется "механизм защиты", чтобы не выйти за пределы имеющихся шести каналов. Помните – переменная с именем currentChannel получает новое значение каждый раз при вызове функции changeTheChannel() (см. шаг 2). Значение этой переменной – номер текущего канала минус 1. Например, если в данный момент включен канал 4, то эта переменная имеет значение 3. Так вот, при вызове функции channelUp, прежде чем выполнить какие-либо действия, оператор if проверяет, возможно ли переключиться на следующий канал: значение currentChannel + 1 должно быть меньше или равно максимальному номеру канала (значение numberOfChannels, или 6). Если это условие выполняется, вызывается функция changeTheChannel(), причем в качестве параметра указывается номер текущего канала плюс 1. В результате на экране будет отображен следующий канал. Здесь оператор if не имеет дополнительной секции else. Таким образом, если условие не выполняется, это значит, что в данный момент демонстрируется канал 6, поэтому никакие действия не выполняются.

function channelDown () {
  if (currentChannel - 1 >= 1) {
    changeTheChannel(currentChannel - 1);
  }
}

Эта функция, подобно channelUp(), не имеет параметров. Чтобы номер канала не оказался меньше 1, первым делом при вызове функции проверяется условие: значение переменной currentChannel, уменьшенное на 1, не должно быть меньше единицы. Если условие выполнено, вызывается функция changeTheChannel(), и в качестве параметра ей передается значение currentChannel минус 1. На экране отображается предыдущий канал. Как и в предыдущей функции, оператор if не имеет дополнительной секции else. Поэтому, если условие не выполняется – значит, что в данный момент демонстрируется канал 1, и никакие действия не выполняются.

Теперь нужно применить только что созданные нами функции channelUp() и channelDown() – их должны вызывать кнопки Up и Down на нашем пульте управления.

on (release) {
  _root.channelUp();
}

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

on (release) {
  _root.channelDown();
}

Эта кнопка, как и предыдущая, вызывает функцию, расположенную на корневом монтажном столе. Каждый раз при нажатии вызывается функция channelDown() и переменная currentChannel уменьшается на единицу (пока не достигнет нижнего предела). Телевизор переключается на соответствующий канал.

Обратите внимание – вы можете выбрать любой канал с помощью одной из цифровых кнопок, а потом уже переключать каналы последовательно кнопками Up и Down. Не правда ли, запрограммировать такое функционирование было несложно – с помощью переменной, хранящей номер текущего канала и созданных нами функций.

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

Использование локальных переменных и создание функций, возвращающих результат

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

В принципе, в ActionScript использовать локальные переменные не обязательно, однако их применение – "хороший тон" в программировании. Если в приложении выполняется много вычислений, это приводит к созданию большого числа переменных, а в результате приложение работает медленнее. Использование же локальных переменных позволяет сэкономить память. Кроме того, это помогает избежать конфликтов имен – это нередко происходит в больших проектах, когда программист легко может создать переменную с именем, которое он уже использовал. А вот локальные переменные, объявленные в разных функциях, вполне могут иметь одинаковые имена, даже если объявления этих функций находятся на одном монтажном столе. Flash не перепутает их – он знает, что локальная переменная существует только внутри функции и только во время выполнения этой функции.

Для создания локальной переменной имеется только один способ. Синтаксис таков:

var myName = "Jobe";

Обратите внимание на слово var: именно оно дает Flash понять, что эта переменная – локальная. Если такая строка присутствует внутри объявления функции, то переменная myName определена (и может быть использована) только внутри этой функции.

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

var firstName = "Jobe", lastName = "Makar", email = "jobe@electrotank.com";

Теперь поговорим о функциях, которые возвращают конечный результат – то есть выдают некоторое значение. Представьте себе, например, калькулятор. Сам калькулятор – это функция, которая манипулирует числами и вызывает другие функции; вводимые вами числа – значения параметров, которые передаются вызываемой функции; а итог – это результат, возвращенный функцией после выполнения. Синтаксис строки для возвращаемого значения таков:

return myVariable;

Функция выполняет действия, чтобы определить конечный результат. Этот результат затем возвращается в строку, содержащую вызов функции. Как только в теле функции встречается действие return, выполнение функции немедленно прекращается – очень удобно, если нужно прервать выполнение функции. Вот пример объявления функции с использованием локальной переменной и возврата:

function convertToMoonWeight (myWeight) {
  var newWeight = myWeight / 6.04;
  return newWeight;
}

Вызов этой функции мог бы выглядеть так:

myWeightOnMoon = convertToMoonWeight(165);

В этой строке ActionScript для присвоения значения переменной myWeightOnMoon используется вызов функции. Вызванная функция возвращает значение newWeight, значит, оно (27.32) и станет значением переменной myWeightOnMoon. Параметр myWeight автоматически создается как локальная переменная, которая удаляется после выполнения функции. Локальная переменная newWeight также удаляется, как только функция завершает свою работу.

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

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

Этот фильм очень похож на тот, с которым мы недавно работали, только под телевизором появилось новое устройство – приемник кабельного ТВ. Это фильм-символ, имя экземпляра – cableBox, содержит он несложную графику и текстовое поле с именем cableDisplay. В этом текстовом поле будет отображаться название выбранного канала.

channelNames = ["","News","Classics","Family","Cartoons","Horror","Westerns"];

Вы только что создали массив с именем channelNames. Массив содержит названия каналов, которые будут динамически вставляться в текстовую строку на кабельном приемнике. В массиве семь элементов строкового типа, разделенных запятыми. Каждому из этих элементов соответствует так называемый индекс, начинаются индексы с нуля. Например, элемент channelNames[0] = "" (пустая строка), channelNames[1] = "News", channelNames[2] = "Classics" и так далее. Эти система индексов будет важна для нас, поэтому постарайтесь понять ее.

Примечание Подробную информацию о массивах вы найдете в Уроке 7 – Работа с динамическими данными.

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

function displayCableText () {
  if (currentChannel != 0) {
    var displayText = "Вы смотрите канал "+channelNames[currentChannel]+".";
  } else {
    var displayText = "";
  }
  return displayText;
}

Это описание функции displayCableText(), которая не имеет параметров. Ее предназначение – динамическое построение строки текста, который должен быть отображен в текстовом поле cableDisplay. Построенную строку функция возвращает действием return. Функция содержит условный оператор, проверяющий выключен ли телевизор (текущий канал не равен 0). Если это условие выполнено, создается локальная переменная displayText и строится текстовая строка с использованием элемента массива channelNames, индекс которого равен текущему значению currentChannel. Например, если в момент выполнения функции значение currentChannel равно 4, то получится вот что:

var displayText = "Вы смотрите канал "+channelNames[4]+".";

Поскольку в массиве channelNames элемент с индексом 4 – это "Cartoons", в итоге получаем:

var displayText = "Вы смотрите канал Cartoons.";

Если условие оператора if не выполнено, вступает в действие секция else: локальная переменная displayText создается с пустым значением (просто ""). Завершается функция возвратом значения displayText. Но куда же именно возвращается это значение? Это разъяснится на следующем шаге. А пока напомним, что, поскольку переменная displayText определена как локальная (с использованием var ), она будет выгружена из памяти сразу после того, как будет возвращено ее значение.

cableBox.cableDisplay.text = displayCableText();

Мы изменили функцию changeTheChannel(), чтобы каждый раз при смене канала (а это происходит при вызове этой функции) обновлялся текст в поле cableDisplay (в экземпляре фильма-символа cableBox ). Вставленная нами строка ActionScript устанавливает текст в экземпляре cableDisplay (это динамическое текстовое поле), используя значение, возвращаемое функцией displayCableText(). Итак, функция displayCableText() вызывается, выполняет свои действия и выдает значение. Это значение подставляется после знака равенства. Вот что означает "функция возвращает значение". Значение, выработанное функцией, возвращается в ту строку скрипта, которая вызвала эту функцию (как вы видели). А еще вы увидели отличный пример того, как функции экономят время при программировании. Мы расширили возможности функции changeTheChannel() – в одном-единственном месте, но все скрипты, вызывающие эту функцию, автоматически стали использовать и эти новые возможности!

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

Мы закончили работу с этим файлом. В ходе работы вы смогли применить все знания, полученные в этом уроке.